cloudwatch

type Client struct {
	// contains filtered or unexported fields
}

type DeleteAlarmsInput struct {
	// The alarms to be deleted.
	AlarmNames []*string
}

type DeleteAlarmsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteAnomalyDetectorInput struct {
	// The metric name associated with the anomaly detection model to delete.
	MetricName *string
	// The metric dimensions associated with the anomaly detection model to delete.
	Dimensions []*types.Dimension
	// The namespace associated with the anomaly detection model to delete.
	Namespace *string
	// The statistic associated with the anomaly detection model to delete.
	Stat *string
}

type DeleteAnomalyDetectorOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDashboardsInput struct {
	// The dashboards to be deleted. This parameter is required.
	DashboardNames []*string
}

type DeleteDashboardsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteInsightRulesInput struct {
	// An array of the rule names to delete. If you need to find out the names of your
	// rules, use DescribeInsightRules
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeInsightRules.html).
	RuleNames []*string
}

type DeleteInsightRulesOutput struct {
	// An array listing the rules that could not be deleted. You cannot delete built-in
	// rules.
	Failures []*types.PartialFailure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAlarmHistoryInput struct {
	// The maximum number of alarm history records to retrieve.
	MaxRecords *int32
	// The starting date to retrieve alarm history.
	StartDate *time.Time
	// Specified whether to return the newest or oldest alarm history first. Specify
	// TimestampDescending to have the newest event history returned first, and specify
	// TimestampAscending to have the oldest history returned first.
	ScanBy types.ScanBy
	// The name of the alarm.
	AlarmName *string
	// The ending date to retrieve alarm history.
	EndDate *time.Time
	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string
	// The type of alarm histories to retrieve.
	HistoryItemType types.HistoryItemType
	// Use this parameter to specify whether you want the operation to return metric
	// alarms or composite alarms. If you omit this parameter, only metric alarms are
	// returned.
	AlarmTypes []types.AlarmType
}

type DescribeAlarmHistoryOutput struct {
	// The token that marks the start of the next batch of returned results.
	NextToken *string
	// The alarm histories, in JSON format.
	AlarmHistoryItems []*types.AlarmHistoryItem

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAlarmsForMetricInput struct {
	// The namespace of the metric.
	Namespace *string
	// The period, in seconds, over which the statistic is applied.
	Period *int32
	// The dimensions associated with the metric. If the metric has any associated
	// dimensions, you must specify them in order for the call to succeed.
	Dimensions []*types.Dimension
	// The statistic for the metric, other than percentiles. For percentile statistics,
	// use ExtendedStatistics.
	Statistic types.Statistic
	// The name of the metric.
	MetricName *string
	// The unit for the metric.
	Unit types.StandardUnit
	// The percentile statistic for the metric. Specify a value between p0.0 and p100.
	ExtendedStatistic *string
}

type DescribeAlarmsForMetricOutput struct {
	// The information for each alarm with the specified metric.
	MetricAlarms []*types.MetricAlarm

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAlarmsInput struct {
	// Use this parameter to specify whether you want the operation to return metric
	// alarms or composite alarms. If you omit this parameter, only metric alarms are
	// returned.
	AlarmTypes []types.AlarmType
	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string
	// Specify this parameter to receive information only about alarms that are
	// currently in the state that you specify.
	StateValue types.StateValue
	// The names of the alarms to retrieve information about.
	AlarmNames []*string
	// If you use this parameter and specify the name of a metric or composite alarm,
	// the operation returns information about the "parent" alarms of the alarm you
	// specify. These are the composite alarms that have AlarmRule parameters that
	// reference the alarm named in ParentsOfAlarmName. Information about the alarm
	// that you specify in ParentsOfAlarmName is not returned. If you specify
	// ParentsOfAlarmName, you cannot specify any other parameters in the request
	// except for MaxRecords and NextToken. If you do so, you receive a validation
	// error. Only the Alarm Name and ARN are returned by this operation when you use
	// this parameter. To get complete information about these alarms, perform another
	// DescribeAlarms operation and specify the parent alarm names in the AlarmNames
	// parameter.
	ParentsOfAlarmName *string
	// Use this parameter to filter the results of the operation to only those alarms
	// that use a certain alarm action. For example, you could specify the ARN of an
	// SNS topic to find all alarms that send notifications to that topic.
	ActionPrefix *string
	// The maximum number of alarm descriptions to retrieve.
	MaxRecords *int32
	// If you use this parameter and specify the name of a composite alarm, the
	// operation returns information about the "children" alarms of the alarm you
	// specify. These are the metric alarms and composite alarms referenced in the
	// AlarmRule field of the composite alarm that you specify in ChildrenOfAlarmName.
	// Information about the composite alarm that you name in ChildrenOfAlarmName is
	// not returned. If you specify ChildrenOfAlarmName, you cannot specify any other
	// parameters in the request except for MaxRecords and NextToken. If you do so, you
	// receive a validation error. Only the Alarm Name, ARN, StateValue
	// (OK/ALARM/INSUFFICIENT_DATA), and StateUpdatedTimestamp information are returned
	// by this operation when you use this parameter. To get complete information about
	// these alarms, perform another DescribeAlarms operation and specify the parent
	// alarm names in the AlarmNames parameter.
	ChildrenOfAlarmName *string
	// An alarm name prefix. If you specify this parameter, you receive information
	// about all alarms that have names that start with this prefix. If this parameter
	// is specified, you cannot specify AlarmNames.
	AlarmNamePrefix *string
}

type DescribeAlarmsOutput struct {
	// The token that marks the start of the next batch of returned results.
	NextToken *string
	// The information about any metric alarms returned by the operation.
	MetricAlarms []*types.MetricAlarm
	// The information about any composite alarms returned by the operation.
	CompositeAlarms []*types.CompositeAlarm

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAnomalyDetectorsInput struct {
	// The maximum number of results to return in one operation. The maximum value that
	// you can specify is 100. To retrieve the remaining results, make another call
	// with the returned NextToken value.
	MaxResults *int32
	// Limits the results to only the anomaly detection models that are associated with
	// the specified metric name. If there are multiple metrics with this name in
	// different namespaces that have anomaly detection models, they're all returned.
	MetricName *string
	// Limits the results to only the anomaly detection models that are associated with
	// the specified metric dimensions. If there are multiple metrics that have these
	// dimensions and have anomaly detection models associated, they're all returned.
	Dimensions []*types.Dimension
	// Use the token returned by the previous operation to request the next page of
	// results.
	NextToken *string
	// Limits the results to only the anomaly detection models that are associated with
	// the specified namespace.
	Namespace *string
}

type DescribeAnomalyDetectorsOutput struct {
	// The list of anomaly detection models returned by the operation.
	AnomalyDetectors []*types.AnomalyDetector
	// A token that you can use in a subsequent operation to retrieve the next set of
	// results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInsightRulesInput struct {
	// Reserved for future use.
	NextToken *string
	// This parameter is not currently used. Reserved for future use. If it is used in
	// the future, the maximum value might be different.
	MaxResults *int32
}

type DescribeInsightRulesOutput struct {
	// The rules returned by the operation.
	InsightRules []*types.InsightRule
	// Reserved for future use.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DisableAlarmActionsInput struct {
	// The names of the alarms.
	AlarmNames []*string
}

type DisableAlarmActionsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DisableInsightRulesInput struct {
	// An array of the rule names to disable. If you need to find out the names of your
	// rules, use DescribeInsightRules
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeInsightRules.html).
	RuleNames []*string
}

type DisableInsightRulesOutput struct {
	// An array listing the rules that could not be disabled. You cannot disable
	// built-in rules.
	Failures []*types.PartialFailure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EnableAlarmActionsInput struct {
	// The names of the alarms.
	AlarmNames []*string
}

type EnableAlarmActionsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EnableInsightRulesInput struct {
	// An array of the rule names to enable. If you need to find out the names of your
	// rules, use DescribeInsightRules
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeInsightRules.html).
	RuleNames []*string
}

type EnableInsightRulesOutput struct {
	// An array listing the rules that could not be enabled. You cannot disable or
	// enable built-in rules.
	Failures []*types.PartialFailure

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type GetDashboardInput struct {
	// The name of the dashboard to be described.
	DashboardName *string
}

type GetDashboardOutput struct {
	// The Amazon Resource Name (ARN) of the dashboard.
	DashboardArn *string
	// The detailed information about the dashboard, including what widgets are
	// included and their location on the dashboard. For more information about the
	// DashboardBody syntax, see Dashboard Body Structure and Syntax
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CloudWatch-Dashboard-Body-Structure.html).
	DashboardBody *string
	// The name of the dashboard.
	DashboardName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetInsightRuleReportInput struct {
	// The start time of the data to use in the report. When used in a raw HTTP Query
	// API, it is formatted as yyyy-MM-dd'T'HH:mm:ss. For example, 2019-07-01T23:59:59.
	StartTime *time.Time
	// The end time of the data to use in the report. When used in a raw HTTP Query
	// API, it is formatted as yyyy-MM-dd'T'HH:mm:ss. For example, 2019-07-01T23:59:59.
	EndTime *time.Time
	// The name of the rule that you want to see data from.
	RuleName *string
	// The maximum number of contributors to include in the report. The range is 1 to
	// 100. If you omit this, the default of 10 is used.
	MaxContributorCount *int32
	// Determines what statistic to use to rank the contributors. Valid values are SUM
	// and MAXIMUM.
	OrderBy *string
	// Specifies which metrics to use for aggregation of contributor values for the
	// report. You can specify one or more of the following metrics:
	//
	//     *
	// UniqueContributors -- the number of unique contributors for each data point.
	//
	//
	// * MaxContributorValue -- the value of the top contributor for each data point.
	// The identity of the contributor might change for each data point in the graph.
	// If this rule aggregates by COUNT, the top contributor for each data point is the
	// contributor with the most occurrences in that period. If the rule aggregates by
	// SUM, the top contributor is the contributor with the highest sum in the log
	// field specified by the rule's Value, during that period.
	//
	//     * SampleCount --
	// the number of data points matched by the rule.
	//
	//     * Sum -- the sum of the
	// values from all contributors during the time period represented by that data
	// point.
	//
	//     * Minimum -- the minimum value from a single observation during the
	// time period represented by that data point.
	//
	//     * Maximum -- the maximum value
	// from a single observation during the time period represented by that data
	// point.
	//
	//     * Average -- the average value from all contributors during the time
	// period represented by that data point.
	Metrics []*string
	// The period, in seconds, to use for the statistics in the
	// InsightRuleMetricDatapoint results.
	Period *int32
}

type GetInsightRuleReportOutput struct {
	// Specifies whether this rule aggregates contributor data by COUNT or SUM.
	AggregationStatistic *string
	// An array of the unique contributors found by this rule in this time period. If
	// the rule contains multiple keys, each combination of values for the keys counts
	// as a unique contributor.
	Contributors []*types.InsightRuleContributor
	// The sum of the values from all individual contributors that match the rule.
	AggregateValue *float64
	// A time series of metric data points that matches the time period in the rule
	// request.
	MetricDatapoints []*types.InsightRuleMetricDatapoint
	// An array of the strings used as the keys for this rule. The keys are the
	// dimensions used to classify contributors. If the rule contains more than one
	// key, then each unique combination of values for the keys is counted as a unique
	// contributor.
	KeyLabels []*string
	// An approximate count of the unique contributors found by this rule in this time
	// period.
	ApproximateUniqueCount *int64

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMetricDataInput struct {
	// The metric queries to be returned. A single GetMetricData call can include as
	// many as 500 MetricDataQuery structures. Each of these structures can specify
	// either a metric to retrieve, or a math expression to perform on retrieved data.
	MetricDataQueries []*types.MetricDataQuery
	// The time stamp indicating the earliest data to be returned. The value specified
	// is inclusive; results include data points with the specified time stamp.
	// CloudWatch rounds the specified time stamp as follows:
	//
	//     * Start time less
	// than 15 days ago - Round down to the nearest whole minute. For example, 12:32:34
	// is rounded down to 12:32:00.
	//
	//     * Start time between 15 and 63 days ago -
	// Round down to the nearest 5-minute clock interval. For example, 12:32:34 is
	// rounded down to 12:30:00.
	//
	//     * Start time greater than 63 days ago - Round
	// down to the nearest 1-hour clock interval. For example, 12:32:34 is rounded down
	// to 12:00:00.
	//
	// If you set Period to 5, 10, or 30, the start time of your request
	// is rounded down to the nearest time that corresponds to even 5-, 10-, or
	// 30-second divisions of a minute. For example, if you make a query at (HH:mm:ss)
	// 01:05:23 for the previous 10-second period, the start time of your request is
	// rounded down and you receive data from 01:05:10 to 01:05:20. If you make a query
	// at 15:07:17 for the previous 5 minutes of data, using a period of 5 seconds, you
	// receive data timestamped between 15:02:15 and 15:07:15. For better performance,
	// specify StartTime and EndTime values that align with the value of the metric's
	// Period and sync up with the beginning and end of an hour. For example, if the
	// Period of a metric is 5 minutes, specifying 12:05 or 12:30 as StartTime can get
	// a faster response from CloudWatch than setting 12:07 or 12:29 as the StartTime.
	StartTime *time.Time
	// Include this value, if it was returned by the previous call, to get the next set
	// of data points.
	NextToken *string
	// The maximum number of data points the request should return before paginating.
	// If you omit this, the default of 100,800 is used.
	MaxDatapoints *int32
	// The order in which data points should be returned. TimestampDescending returns
	// the newest data first and paginates when the MaxDatapoints limit is reached.
	// TimestampAscending returns the oldest data first and paginates when the
	// MaxDatapoints limit is reached.
	ScanBy types.ScanBy
	// The time stamp indicating the latest data to be returned. The value specified is
	// exclusive; results include data points up to the specified time stamp. For
	// better performance, specify StartTime and EndTime values that align with the
	// value of the metric's Period and sync up with the beginning and end of an hour.
	// For example, if the Period of a metric is 5 minutes, specifying 12:05 or 12:30
	// as EndTime can get a faster response from CloudWatch than setting 12:07 or 12:29
	// as the EndTime.
	EndTime *time.Time
}

type GetMetricDataOutput struct {
	// Contains a message about this GetMetricData operation, if the operation results
	// in such a message. An example of a message that might be returned is Maximum
	// number of allowed metrics exceeded. If there is a message, as much of the
	// operation as possible is still executed. A message appears here only if it is
	// related to the global GetMetricData operation. Any message about a specific
	// metric returned by the operation appears in the MetricDataResult object returned
	// for that metric.
	Messages []*types.MessageData
	// The metrics that are returned, including the metric name, namespace, and
	// dimensions.
	MetricDataResults []*types.MetricDataResult
	// A token that marks the next batch of returned results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMetricStatisticsInput struct {
	// The name of the metric, with or without spaces.
	MetricName *string
	// The time stamp that determines the last data point to return. The value
	// specified is exclusive; results include data points up to the specified time
	// stamp. In a raw HTTP query, the time stamp must be in ISO 8601 UTC format (for
	// example, 2016-10-10T23:00:00Z).
	EndTime *time.Time
	// The time stamp that determines the first data point to return. Start times are
	// evaluated relative to the time that CloudWatch receives the request. The value
	// specified is inclusive; results include data points with the specified time
	// stamp. In a raw HTTP query, the time stamp must be in ISO 8601 UTC format (for
	// example, 2016-10-03T23:00:00Z). CloudWatch rounds the specified time stamp as
	// follows:
	//
	//     * Start time less than 15 days ago - Round down to the nearest
	// whole minute. For example, 12:32:34 is rounded down to 12:32:00.
	//
	//     * Start
	// time between 15 and 63 days ago - Round down to the nearest 5-minute clock
	// interval. For example, 12:32:34 is rounded down to 12:30:00.
	//
	//     * Start time
	// greater than 63 days ago - Round down to the nearest 1-hour clock interval. For
	// example, 12:32:34 is rounded down to 12:00:00.
	//
	// If you set Period to 5, 10, or
	// 30, the start time of your request is rounded down to the nearest time that
	// corresponds to even 5-, 10-, or 30-second divisions of a minute. For example, if
	// you make a query at (HH:mm:ss) 01:05:23 for the previous 10-second period, the
	// start time of your request is rounded down and you receive data from 01:05:10 to
	// 01:05:20. If you make a query at 15:07:17 for the previous 5 minutes of data,
	// using a period of 5 seconds, you receive data timestamped between 15:02:15 and
	// 15:07:15.
	StartTime *time.Time
	// The dimensions. If the metric contains multiple dimensions, you must include a
	// value for each dimension. CloudWatch treats each unique combination of
	// dimensions as a separate metric. If a specific combination of dimensions was not
	// published, you can't retrieve statistics for it. You must specify the same
	// dimensions that were used when the metrics were created. For an example, see
	// Dimension Combinations
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#dimension-combinations)
	// in the Amazon CloudWatch User Guide. For more information about specifying
	// dimensions, see Publishing Metrics
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html)
	// in the Amazon CloudWatch User Guide.
	Dimensions []*types.Dimension
	// The granularity, in seconds, of the returned data points. For metrics with
	// regular resolution, a period can be as short as one minute (60 seconds) and must
	// be a multiple of 60. For high-resolution metrics that are collected at intervals
	// of less than one minute, the period can be 1, 5, 10, 30, 60, or any multiple of
	// 60. High-resolution metrics are those metrics stored by a PutMetricData call
	// that includes a StorageResolution of 1 second. If the StartTime parameter
	// specifies a time stamp that is greater than 3 hours ago, you must specify the
	// period as follows or no data points in that time range is returned:
	//
	//     * Start
	// time between 3 hours and 15 days ago - Use a multiple of 60 seconds (1
	// minute).
	//
	//     * Start time between 15 and 63 days ago - Use a multiple of 300
	// seconds (5 minutes).
	//
	//     * Start time greater than 63 days ago - Use a multiple
	// of 3600 seconds (1 hour).
	Period *int32
	// The unit for a given metric. If you omit Unit, all data that was collected with
	// any unit is returned, along with the corresponding units that were specified
	// when the data was reported to CloudWatch. If you specify a unit, the operation
	// returns only data that was collected with that unit specified. If you specify a
	// unit that does not match the data collected, the results of the operation are
	// null. CloudWatch does not perform unit conversions.
	Unit types.StandardUnit
	// The metric statistics, other than percentile. For percentile statistics, use
	// ExtendedStatistics. When calling GetMetricStatistics, you must specify either
	// Statistics or ExtendedStatistics, but not both.
	Statistics []types.Statistic
	// The namespace of the metric, with or without spaces.
	Namespace *string
	// The percentile statistics. Specify values between p0.0 and p100. When calling
	// GetMetricStatistics, you must specify either Statistics or ExtendedStatistics,
	// but not both. Percentile statistics are not available for metrics when any of
	// the metric values are negative numbers.
	ExtendedStatistics []*string
}

type GetMetricStatisticsOutput struct {
	// A label for the specified metric.
	Label *string
	// The data points for the specified metric.
	Datapoints []*types.Datapoint

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMetricWidgetImageInput struct {
	// A JSON string that defines the bitmap graph to be retrieved. The string includes
	// the metrics to include in the graph, statistics, annotations, title, axis
	// limits, and so on. You can include only one MetricWidget parameter in each
	// GetMetricWidgetImage call. For more information about the syntax of MetricWidget
	// see GetMetricWidgetImage: Metric Widget Structure and Syntax
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CloudWatch-Metric-Widget-Structure.html).
	// <p>If any metric on the graph could not load all the requested data points, an
	// orange triangle with an exclamation point appears next to the graph legend.</p>
	MetricWidget *string
	// The format of the resulting image. Only PNG images are supported.  <p>The
	// default is <code>png</code>. If you specify <code>png</code>, the API returns an
	// HTTP response with the content-type set to <code>text/xml</code>. The image data
	// is in a <code>MetricWidgetImage</code> field. For example:</p> <p> <code>
	// <GetMetricWidgetImageResponse xmlns=<URLstring>></code> </p> <p> <code>
	// <GetMetricWidgetImageResult></code> </p> <p> <code> <MetricWidgetImage></code>
	// </p> <p> <code> iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQEAYAAAAip...</code> </p> <p>
	// <code> </MetricWidgetImage></code> </p> <p> <code>
	// </GetMetricWidgetImageResult></code> </p> <p> <code> <ResponseMetadata></code>
	// </p> <p> <code>
	// <RequestId>6f0d4192-4d42-11e8-82c1-f539a07e0e3b</RequestId></code> </p> <p>
	// <code> </ResponseMetadata></code> </p> <p>
	// <code></GetMetricWidgetImageResponse></code> </p> <p>The <code>image/png</code>
	// setting is intended only for custom HTTP requests. For most use cases, and all
	// actions using an AWS SDK, you should use <code>png</code>. If you specify
	// <code>image/png</code>, the HTTP response has a content-type set to
	// <code>image/png</code>, and the body of the response is a PNG image. </p>
	OutputFormat *string
}

type GetMetricWidgetImageOutput struct {
	// The image of the graph, in the output format specified. The output is
	// base64-encoded.
	MetricWidgetImage []byte

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type ListDashboardsInput struct {
	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string
	// If you specify this parameter, only the dashboards with names starting with the
	// specified string are listed. The maximum length is 255, and valid characters are
	// A-Z, a-z, 0-9, ".", "-", and "_".  </p>
	DashboardNamePrefix *string
}

type ListDashboardsOutput struct {
	// The list of matching dashboards.
	DashboardEntries []*types.DashboardEntry
	// The token that marks the start of the next batch of returned results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListMetricsInput struct {
	// The name of the metric to filter against.
	MetricName *string
	// The namespace to filter against.
	Namespace *string
	// To filter the results to show only metrics that have had data points published
	// in the past three hours, specify this parameter with a value of PT3H. This is
	// the only valid value for this parameter. The results that are returned are an
	// approximation of the value you specify. There is a low probability that the
	// returned results include metrics with last published data as much as 40 minutes
	// more than the specified time interval.
	RecentlyActive types.RecentlyActive
	// The dimensions to filter against.
	Dimensions []*types.DimensionFilter
	// The token returned by a previous call to indicate that there is more data
	// available.
	NextToken *string
}

type ListMetricsOutput struct {
	// The token that marks the start of the next batch of returned results.
	NextToken *string
	// The metrics that match your request.
	Metrics []*types.Metric

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTagsForResourceInput struct {
	// The ARN of the CloudWatch resource that you want to view tags for. The ARN
	// format of an alarm is arn:aws:cloudwatch:Region:account-id:alarm:alarm-name  The
	// ARN format of a Contributor Insights rule is
	// arn:aws:cloudwatch:Region:account-id:insight-rule:insight-rule-name  For more
	// information about ARN format, see  Resource Types Defined by Amazon CloudWatch
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazoncloudwatch.html#amazoncloudwatch-resources-for-iam-policies)
	// in the Amazon Web Services General Reference.
	ResourceARN *string
}

type ListTagsForResourceOutput struct {
	// The list of tag keys and values associated with the resource you specified.
	Tags []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PutAnomalyDetectorInput struct {
	// The name of the metric to create the anomaly detection model for.
	MetricName *string
	// The configuration specifies details about how the anomaly detection model is to
	// be trained, including time ranges to exclude when training and updating the
	// model. You can specify as many as 10 time ranges. The configuration can also
	// include the time zone to use for the metric. You can in
	Configuration *types.AnomalyDetectorConfiguration
	// The metric dimensions to create the anomaly detection model for.
	Dimensions []*types.Dimension
	// The statistic to use for the metric and the anomaly detection model.
	Stat *string
	// The namespace of the metric to create the anomaly detection model for.
	Namespace *string
}

type PutAnomalyDetectorOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutCompositeAlarmInput struct {
	// Indicates whether actions should be executed during any changes to the alarm
	// state of the composite alarm. The default is TRUE.
	ActionsEnabled *bool
	// An expression that specifies which other alarms are to be evaluated to determine
	// this composite alarm's state. For each alarm that you reference, you designate a
	// function that specifies whether that alarm needs to be in ALARM state, OK state,
	// or INSUFFICIENT_DATA state. You can use operators (AND, OR and NOT) to combine
	// multiple functions in a single expression. You can use parenthesis to logically
	// group the functions in your expression. You can use either alarm names or ARNs
	// to reference the other alarms that are to be evaluated. Functions can include
	// the following:
	//
	//     * ALARM("alarm-name or alarm-ARN") is TRUE if the named
	// alarm is in ALARM state.
	//
	//     * OK("alarm-name or alarm-ARN") is TRUE if the
	// named alarm is in OK state.
	//
	//     * INSUFFICIENT_DATA("alarm-name or alarm-ARN")
	// is TRUE if the named alarm is in INSUFFICIENT_DATA state.
	//
	//     * TRUE always
	// evaluates to TRUE.
	//
	//     * FALSE always evaluates to FALSE.
	//
	// TRUE and FALSE are
	// useful for testing a complex AlarmRule structure, and for testing your alarm
	// actions. Alarm names specified in AlarmRule can be surrounded with double-quotes
	// ("), but do not have to be. The following are some examples of AlarmRule:
	//
	//     *
	// ALARM(CPUUtilizationTooHigh) AND ALARM(DiskReadOpsTooHigh) specifies that the
	// composite alarm goes into ALARM state only if both CPUUtilizationTooHigh and
	// DiskReadOpsTooHigh alarms are in ALARM state.
	//
	//     *
	// ALARM(CPUUtilizationTooHigh) AND NOT ALARM(DeploymentInProgress) specifies that
	// the alarm goes to ALARM state if CPUUtilizationTooHigh is in ALARM state and
	// DeploymentInProgress is not in ALARM state. This example reduces alarm noise
	// during a known deployment window.
	//
	//     * (ALARM(CPUUtilizationTooHigh) OR
	// ALARM(DiskReadOpsTooHigh)) AND OK(NetworkOutTooHigh) goes into ALARM state if
	// CPUUtilizationTooHigh OR DiskReadOpsTooHigh is in ALARM state, and if
	// NetworkOutTooHigh is in OK state. This provides another example of using a
	// composite alarm to prevent noise. This rule ensures that you are not notified
	// with an alarm action on high CPU or disk usage if a known network problem is
	// also occurring.
	//
	// The AlarmRule can specify as many as 100 "children" alarms. The
	// AlarmRule expression can have as many as 500 elements. Elements are child
	// alarms, TRUE or FALSE statements, and parentheses.
	AlarmRule *string
	// The description for the composite alarm.
	AlarmDescription *string
	// The actions to execute when this alarm transitions to the ALARM state from any
	// other state. Each action is specified as an Amazon Resource Name (ARN).
	// <p>Valid Values:
	// <code>arn:aws:sns:<i>region</i>:<i>account-id</i>:<i>sns-topic-name</i> </code>
	// </p>
	AlarmActions []*string
	// The actions to execute when this alarm transitions to the INSUFFICIENT_DATA
	// state from any other state. Each action is specified as an Amazon Resource Name
	// (ARN).  <p>Valid Values:
	// <code>arn:aws:sns:<i>region</i>:<i>account-id</i>:<i>sns-topic-name</i> </code>
	// </p>
	InsufficientDataActions []*string
	// The name for the composite alarm. This name must be unique within the Region.
	AlarmName *string
	// The actions to execute when this alarm transitions to an OK state from any other
	// state. Each action is specified as an Amazon Resource Name (ARN).  <p>Valid
	// Values: <code>arn:aws:sns:<i>region</i>:<i>account-id</i>:<i>sns-topic-name</i>
	// </code> </p>
	OKActions []*string
	// A list of key-value pairs to associate with the composite alarm. You can
	// associate as many as 50 tags with an alarm. Tags can help you organize and
	// categorize your resources. You can also use them to scope user permissions, by
	// granting a user permission to access or change only resources with certain tag
	// values.
	Tags []*types.Tag
}

type PutCompositeAlarmOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutDashboardInput struct {
	// The detailed information about the dashboard in JSON format, including the
	// widgets to include and their location on the dashboard. This parameter is
	// required. For more information about the syntax, see Dashboard Body Structure
	// and Syntax
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CloudWatch-Dashboard-Body-Structure.html).
	DashboardBody *string
	// The name of the dashboard. If a dashboard with this name already exists, this
	// call modifies that dashboard, replacing its current contents. Otherwise, a new
	// dashboard is created. The maximum length is 255, and valid characters are A-Z,
	// a-z, 0-9, "-", and "_". This parameter is required.
	DashboardName *string
}

type PutDashboardOutput struct {
	// If the input for PutDashboard was correct and the dashboard was successfully
	// created or modified, this result is empty. If this result includes only warning
	// messages, then the input was valid enough for the dashboard to be created or
	// modified, but some elements of the dashboard might not render. If this result
	// includes error messages, the input was not valid and the operation failed.
	DashboardValidationMessages []*types.DashboardValidationMessage

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutInsightRuleInput struct {
	// The state of the rule. Valid values are ENABLED and DISABLED.
	RuleState *string
	// A unique name for the rule.
	RuleName *string
	// A list of key-value pairs to associate with the Contributor Insights rule. You
	// can associate as many as 50 tags with a rule. Tags can help you organize and
	// categorize your resources. You can also use them to scope user permissions, by
	// granting a user permission to access or change only the resources that have
	// certain tag values. To be able to associate tags with a rule, you must have the
	// cloudwatch:TagResource permission in addition to the cloudwatch:PutInsightRule
	// permission. If you are using this operation to update an existing Contributor
	// Insights rule, any tags you specify in this parameter are ignored. To change the
	// tags of an existing rule, use TagResource
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_TagResource.html).
	Tags []*types.Tag
	// The definition of the rule, as a JSON object. For details on the valid syntax,
	// see Contributor Insights Rule Syntax
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights-RuleSyntax.html).
	RuleDefinition *string
}

type PutInsightRuleOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutMetricAlarmInput struct {
	// The unit of measure for the statistic. For example, the units for the Amazon EC2
	// NetworkIn metric are Bytes because NetworkIn tracks the number of bytes that an
	// instance receives on all network interfaces. You can also specify a unit when
	// you create a custom metric. Units help provide conceptual meaning to your data.
	// Metric data points that specify a unit of measure, such as Percent, are
	// aggregated separately. If you don't specify Unit, CloudWatch retrieves all unit
	// types that have been published for the metric and attempts to evaluate the
	// alarm. Usually, metrics are published with only one unit, so the alarm works as
	// intended. However, if the metric is published with multiple types of units and
	// you don't specify a unit, the alarm's behavior is not defined and it behaves
	// predictably. We recommend omitting Unit so that you don't inadvertently specify
	// an incorrect unit that is not published for this metric. Doing so causes the
	// alarm to be stuck in the INSUFFICIENT DATA state.
	Unit types.StandardUnit
	// The length, in seconds, used each time the metric specified in MetricName is
	// evaluated. Valid values are 10, 30, and any multiple of 60. Period is required
	// for alarms based on static thresholds. If you are creating an alarm based on a
	// metric math expression, you specify the period for each metric within the
	// objects in the Metrics array. Be sure to specify 10 or 30 only for metrics that
	// are stored by a PutMetricData call with a StorageResolution of 1. If you specify
	// a period of 10 or 30 for a metric that does not have sub-minute resolution, the
	// alarm still attempts to gather data at the period rate that you specify. In this
	// case, it does not receive data for the attempts that do not correspond to a
	// one-minute data resolution, and the alarm might often lapse into
	// INSUFFICENT_DATA status. Specifying 10 or 30 also sets this alarm as a
	// high-resolution alarm, which has a higher charge than other alarms. For more
	// information about pricing, see Amazon CloudWatch Pricing
	// (https://aws.amazon.com/cloudwatch/pricing/). An alarm's total current
	// evaluation period can be no longer than one day, so Period multiplied by
	// EvaluationPeriods cannot be more than 86,400 seconds.
	Period *int32
	// If this is an alarm based on an anomaly detection model, make this value match
	// the ID of the ANOMALY_DETECTION_BAND function. For an example of how to use this
	// parameter, see the Anomaly Detection Model Alarm example on this page. If your
	// alarm uses this parameter, it cannot have Auto Scaling actions.
	ThresholdMetricId *string
	// The value against which the specified statistic is compared. This parameter is
	// required for alarms based on static thresholds, but should not be used for
	// alarms based on anomaly detection models.
	Threshold *float64
	// The arithmetic operation to use when comparing the specified statistic and
	// threshold. The specified statistic value is used as the first operand. The
	// values LessThanLowerOrGreaterThanUpperThreshold, LessThanLowerThreshold, and
	// GreaterThanUpperThreshold are used only for alarms based on anomaly detection
	// models.
	ComparisonOperator types.ComparisonOperator
	// Used only for alarms based on percentiles. If you specify ignore, the alarm
	// state does not change during periods with too few data points to be
	// statistically significant. If you specify evaluate or omit this parameter, the
	// alarm is always evaluated and possibly changes state no matter how many data
	// points are available. For more information, see Percentile-Based CloudWatch
	// Alarms and Low Data Samples
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#percentiles-with-low-samples).
	// Valid Values: evaluate | ignore
	EvaluateLowSampleCountPercentile *string
	// The percentile statistic for the metric specified in MetricName. Specify a value
	// between p0.0 and p100. When you call PutMetricAlarm and specify a MetricName,
	// you must specify either Statistic or ExtendedStatistic, but not both.
	ExtendedStatistic *string
	// The number of data points 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
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarm-evaluation)
	// in the Amazon CloudWatch User Guide.
	DatapointsToAlarm *int32
	// Sets how this alarm is to handle missing data points. If TreatMissingData is
	// omitted, the default behavior of missing is used. For more information, see
	// Configuring How CloudWatch Alarms Treats Missing Data
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-missing-data).
	// Valid Values: breaching | notBreaching | ignore | missing
	TreatMissingData *string
	// A list of key-value pairs to associate with the alarm. You can associate as many
	// as 50 tags with an alarm. Tags can help you organize and categorize your
	// resources. You can also use them to scope user permissions by granting a user
	// permission to access or change only resources with certain tag values.
	Tags []*types.Tag
	// The name for the alarm. This name must be unique within the Region.
	AlarmName *string
	// The name for the metric associated with the alarm. For each PutMetricAlarm
	// operation, you must specify either MetricName or a Metrics array. If you are
	// creating an alarm based on a math expression, you cannot specify this parameter,
	// or any of the Dimensions, Period, Namespace, Statistic, or ExtendedStatistic
	// parameters. Instead, you specify all this information in the Metrics array.
	MetricName *string
	// The description for the alarm.
	AlarmDescription *string
	// Indicates whether actions should be executed during any changes to the alarm
	// state. The default is TRUE.
	ActionsEnabled *bool
	// The actions to execute when this alarm transitions to the ALARM state from any
	// other state. Each action is specified as an Amazon Resource Name (ARN).
	// <p>Valid Values: <code>arn:aws:automate:<i>region</i>:ec2:stop</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:terminate</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:recover</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:reboot</code> |
	// <code>arn:aws:sns:<i>region</i>:<i>account-id</i>:<i>sns-topic-name</i> </code>
	// |
	// <code>arn:aws:autoscaling:<i>region</i>:<i>account-id</i>:scalingPolicy:<i>policy-id</i>:autoScalingGroupName/<i>group-friendly-name</i>:policyName/<i>policy-friendly-name</i>
	// </code> </p> <p>Valid Values (for use with IAM roles):
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Stop/1.0</code>
	// |
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Terminate/1.0</code>
	// |
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Reboot/1.0</code>
	// </p>
	AlarmActions []*string
	// The dimensions for the metric specified in MetricName.
	Dimensions []*types.Dimension
	// The actions to execute when this alarm transitions to the INSUFFICIENT_DATA
	// state from any other state. Each action is specified as an Amazon Resource Name
	// (ARN).  <p>Valid Values: <code>arn:aws:automate:<i>region</i>:ec2:stop</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:terminate</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:recover</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:reboot</code> |
	// <code>arn:aws:sns:<i>region</i>:<i>account-id</i>:<i>sns-topic-name</i> </code>
	// |
	// <code>arn:aws:autoscaling:<i>region</i>:<i>account-id</i>:scalingPolicy:<i>policy-id</i>:autoScalingGroupName/<i>group-friendly-name</i>:policyName/<i>policy-friendly-name</i>
	// </code> </p> <p>Valid Values (for use with IAM roles):
	// <code>>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Stop/1.0</code>
	// |
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Terminate/1.0</code>
	// |
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Reboot/1.0</code>
	// </p>
	InsufficientDataActions []*string
	// The actions to execute when this alarm transitions to an OK state from any other
	// state. Each action is specified as an Amazon Resource Name (ARN).  <p>Valid
	// Values: <code>arn:aws:automate:<i>region</i>:ec2:stop</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:terminate</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:recover</code> |
	// <code>arn:aws:automate:<i>region</i>:ec2:reboot</code> |
	// <code>arn:aws:sns:<i>region</i>:<i>account-id</i>:<i>sns-topic-name</i> </code>
	// |
	// <code>arn:aws:autoscaling:<i>region</i>:<i>account-id</i>:scalingPolicy:<i>policy-id</i>:autoScalingGroupName/<i>group-friendly-name</i>:policyName/<i>policy-friendly-name</i>
	// </code> </p> <p>Valid Values (for use with IAM roles):
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Stop/1.0</code>
	// |
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Terminate/1.0</code>
	// |
	// <code>arn:aws:swf:<i>region</i>:<i>account-id</i>:action/actions/AWS_EC2.InstanceId.Reboot/1.0</code>
	// </p>
	OKActions []*string
	// The namespace for the metric associated specified in MetricName.
	Namespace *string
	// The number of periods over which data is compared to the specified threshold. If
	// you are setting an alarm that requires that a number of consecutive data points
	// be breaching to trigger the alarm, this value specifies that number. If you are
	// setting an "M out of N" alarm, this value is the N. An alarm's total current
	// evaluation period can be no longer than one day, so this number multiplied by
	// Period cannot be more than 86,400 seconds.
	EvaluationPeriods *int32
	// An array of MetricDataQuery structures that enable you to create an alarm based
	// on the result of a metric math expression. For each PutMetricAlarm operation,
	// you must specify either MetricName or a Metrics array. Each item in the Metrics
	// array either retrieves a metric or performs a math expression. One item in the
	// Metrics array is the expression that the alarm watches. You designate this
	// expression by setting ReturnValue to true for this object in the array. For more
	// information, see MetricDataQuery
	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDataQuery.html).
	// If you use the Metrics parameter, you cannot include the MetricName, Dimensions,
	// Period, Namespace, Statistic, or ExtendedStatistic parameters of PutMetricAlarm
	// in the same operation. Instead, you retrieve the metrics you are using in your
	// math expression as part of the Metrics array.
	Metrics []*types.MetricDataQuery
	// The statistic for the metric specified in MetricName, other than percentile. For
	// percentile statistics, use ExtendedStatistic. When you call PutMetricAlarm and
	// specify a MetricName, you must specify either Statistic or ExtendedStatistic,
	// but not both.
	Statistic types.Statistic
}

type PutMetricAlarmOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type PutMetricDataInput struct {
	// The namespace for the metric data. To avoid conflicts with AWS service
	// namespaces, you should not specify a namespace that begins with AWS/
	Namespace *string
	// The data for the metric. The array can include no more than 20 metrics per call.
	MetricData []*types.MetricDatum
}

type PutMetricDataOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type SetAlarmStateInput struct {
	// The reason that this alarm is set to this specific state, in text format.
	StateReason *string
	// The reason that this alarm is set to this specific state, in JSON format. For
	// SNS or EC2 alarm actions, this is just informational. But for EC2 Auto Scaling
	// or application Auto Scaling alarm actions, the Auto Scaling policy uses the
	// information in this field to take the correct action.
	StateReasonData *string
	// The value of the state.
	StateValue types.StateValue
	// The name of the alarm.
	AlarmName *string
}

type SetAlarmStateOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagResourceInput struct {
	// The list of key-value pairs to associate with the alarm.
	Tags []*types.Tag
	// The ARN of the CloudWatch resource that you're adding tags to. The ARN format of
	// an alarm is arn:aws:cloudwatch:Region:account-id:alarm:alarm-name  The ARN
	// format of a Contributor Insights rule is
	// arn:aws:cloudwatch:Region:account-id:insight-rule:insight-rule-name  For more
	// information about ARN format, see  Resource Types Defined by Amazon CloudWatch
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazoncloudwatch.html#amazoncloudwatch-resources-for-iam-policies)
	// in the Amazon Web Services General Reference.
	ResourceARN *string
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UntagResourceInput struct {
	// The ARN of the CloudWatch resource that you're removing tags from. The ARN
	// format of an alarm is arn:aws:cloudwatch:Region:account-id:alarm:alarm-name  The
	// ARN format of a Contributor Insights rule is
	// arn:aws:cloudwatch:Region:account-id:insight-rule:insight-rule-name  For more
	// information about ARN format, see  Resource Types Defined by Amazon CloudWatch
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazoncloudwatch.html#amazoncloudwatch-resources-for-iam-policies)
	// in the Amazon Web Services General Reference.
	ResourceARN *string
	// The list of tag keys to remove from the resource.
	TagKeys []*string
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}