Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AlarmHistoryItem

type AlarmHistoryItem struct {

	// The descriptive name for the alarm.
	AlarmName *string

	// The type of alarm, either metric alarm or composite alarm.
	AlarmType AlarmType

	// Data about the alarm, in JSON format.
	HistoryData *string

	// The type of alarm history item.
	HistoryItemType HistoryItemType

	// A summary of the alarm history, in text format.
	HistorySummary *string

	// The time stamp for the alarm history item.
	Timestamp *time.Time
}

    Represents the history of a specific alarm.

    type AlarmType

    type AlarmType string
    const (
    	AlarmTypeCompositeAlarm AlarmType = "CompositeAlarm"
    	AlarmTypeMetricAlarm    AlarmType = "MetricAlarm"
    )

      Enum values for AlarmType

      func (AlarmType) Values

      func (AlarmType) Values() []AlarmType

        Values returns all known values for AlarmType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type AnomalyDetector

        type AnomalyDetector struct {
        
        	// The configuration specifies details about how the anomaly detection model is to
        	// be trained, including time ranges to exclude from use for training the model,
        	// and the time zone to use for the metric.
        	Configuration *AnomalyDetectorConfiguration
        
        	// The metric dimensions associated with the anomaly detection model.
        	Dimensions []Dimension
        
        	// The name of the metric associated with the anomaly detection model.
        	MetricName *string
        
        	// The namespace of the metric associated with the anomaly detection model.
        	Namespace *string
        
        	// The statistic associated with the anomaly detection model.
        	Stat *string
        
        	// The current status of the anomaly detector's training. The possible values are
        	// TRAINED | PENDING_TRAINING | TRAINED_INSUFFICIENT_DATA
        	StateValue AnomalyDetectorStateValue
        }

          An anomaly detection model associated with a particular CloudWatch metric and statistic. You can use the model to display a band of expected normal values when the metric is graphed.

          type AnomalyDetectorConfiguration

          type AnomalyDetectorConfiguration struct {
          
          	// An array of time ranges to exclude from use when the anomaly detection model is
          	// trained. Use this to make sure that events that could cause unusual values for
          	// the metric, such as deployments, aren't used when CloudWatch creates the model.
          	ExcludedTimeRanges []Range
          
          	// The time zone to use for the metric. This is useful to enable the model to
          	// automatically account for daylight savings time changes if the metric is
          	// sensitive to such time changes. To specify a time zone, use the name of the time
          	// zone as specified in the standard tz database. For more information, see tz
          	// database (https://en.wikipedia.org/wiki/Tz_database).
          	MetricTimezone *string
          }

            The configuration specifies details about how the anomaly detection model is to be trained, including time ranges to exclude from use for training the model and the time zone to use for the metric.

            type AnomalyDetectorStateValue

            type AnomalyDetectorStateValue string
            const (
            	AnomalyDetectorStateValuePendingTraining         AnomalyDetectorStateValue = "PENDING_TRAINING"
            	AnomalyDetectorStateValueTrainedInsufficientData AnomalyDetectorStateValue = "TRAINED_INSUFFICIENT_DATA"
            	AnomalyDetectorStateValueTrained                 AnomalyDetectorStateValue = "TRAINED"
            )

              Enum values for AnomalyDetectorStateValue

              func (AnomalyDetectorStateValue) Values

                Values returns all known values for AnomalyDetectorStateValue. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                type ComparisonOperator

                type ComparisonOperator string
                const (
                	ComparisonOperatorGreaterThanOrEqualToThreshold            ComparisonOperator = "GreaterThanOrEqualToThreshold"
                	ComparisonOperatorGreaterThanThreshold                     ComparisonOperator = "GreaterThanThreshold"
                	ComparisonOperatorLessThanThreshold                        ComparisonOperator = "LessThanThreshold"
                	ComparisonOperatorLessThanOrEqualToThreshold               ComparisonOperator = "LessThanOrEqualToThreshold"
                	ComparisonOperatorLessThanLowerOrGreaterThanUpperThreshold ComparisonOperator = "LessThanLowerOrGreaterThanUpperThreshold"
                	ComparisonOperatorLessThanLowerThreshold                   ComparisonOperator = "LessThanLowerThreshold"
                	ComparisonOperatorGreaterThanUpperThreshold                ComparisonOperator = "GreaterThanUpperThreshold"
                )

                  Enum values for ComparisonOperator

                  func (ComparisonOperator) Values

                    Values returns all known values for ComparisonOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type CompositeAlarm

                    type CompositeAlarm struct {
                    
                    	// Indicates whether actions should be executed during any changes to the alarm
                    	// state.
                    	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).
                    	AlarmActions []string
                    
                    	// The Amazon Resource Name (ARN) of the alarm.
                    	AlarmArn *string
                    
                    	// The time stamp of the last update to the alarm configuration.
                    	AlarmConfigurationUpdatedTimestamp *time.Time
                    
                    	// The description of the alarm.
                    	AlarmDescription *string
                    
                    	// The name of the alarm.
                    	AlarmName *string
                    
                    	// The rule that this alarm uses to evaluate its alarm state.
                    	AlarmRule *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).
                    	InsufficientDataActions []string
                    
                    	// The actions to execute when this alarm transitions to the OK state from any
                    	// other state. Each action is specified as an Amazon Resource Name (ARN).
                    	OKActions []string
                    
                    	// An explanation for the alarm state, in text format.
                    	StateReason *string
                    
                    	// An explanation for the alarm state, in JSON format.
                    	StateReasonData *string
                    
                    	// The time stamp of the last update to the alarm state.
                    	StateUpdatedTimestamp *time.Time
                    
                    	// The state value for the alarm.
                    	StateValue StateValue
                    }

                      The details about a composite alarm.

                      type ConcurrentModificationException

                      type ConcurrentModificationException struct {
                      	Message *string
                      }

                        More than one process tried to modify a resource at the same time.

                        func (*ConcurrentModificationException) Error

                        func (*ConcurrentModificationException) ErrorCode

                        func (e *ConcurrentModificationException) ErrorCode() string

                        func (*ConcurrentModificationException) ErrorFault

                        func (*ConcurrentModificationException) ErrorMessage

                        func (e *ConcurrentModificationException) ErrorMessage() string

                        type DashboardEntry

                        type DashboardEntry struct {
                        
                        	// The Amazon Resource Name (ARN) of the dashboard.
                        	DashboardArn *string
                        
                        	// The name of the dashboard.
                        	DashboardName *string
                        
                        	// The time stamp of when the dashboard was last modified, either by an API call or
                        	// through the console. This number is expressed as the number of milliseconds
                        	// since Jan 1, 1970 00:00:00 UTC.
                        	LastModified *time.Time
                        
                        	// The size of the dashboard, in bytes.
                        	Size int64
                        }

                          Represents a specific dashboard.

                          type DashboardInvalidInputError

                          type DashboardInvalidInputError struct {
                          	Message *string
                          
                          	DashboardValidationMessages []DashboardValidationMessage
                          }

                            Some part of the dashboard data is invalid.

                            func (*DashboardInvalidInputError) Error

                            func (*DashboardInvalidInputError) ErrorCode

                            func (e *DashboardInvalidInputError) ErrorCode() string

                            func (*DashboardInvalidInputError) ErrorFault

                            func (*DashboardInvalidInputError) ErrorMessage

                            func (e *DashboardInvalidInputError) ErrorMessage() string

                            type DashboardNotFoundError

                            type DashboardNotFoundError struct {
                            	Message *string
                            }

                              The specified dashboard does not exist.

                              func (*DashboardNotFoundError) Error

                              func (e *DashboardNotFoundError) Error() string

                              func (*DashboardNotFoundError) ErrorCode

                              func (e *DashboardNotFoundError) ErrorCode() string

                              func (*DashboardNotFoundError) ErrorFault

                              func (e *DashboardNotFoundError) ErrorFault() smithy.ErrorFault

                              func (*DashboardNotFoundError) ErrorMessage

                              func (e *DashboardNotFoundError) ErrorMessage() string

                              type DashboardValidationMessage

                              type DashboardValidationMessage struct {
                              
                              	// The data path related to the message.
                              	DataPath *string
                              
                              	// A message describing the error or warning.
                              	Message *string
                              }

                                An error or warning for the operation.

                                type Datapoint

                                type Datapoint struct {
                                
                                	// The average of the metric values that correspond to the data point.
                                	Average *float64
                                
                                	// The percentile statistic for the data point.
                                	ExtendedStatistics map[string]float64
                                
                                	// The maximum metric value for the data point.
                                	Maximum *float64
                                
                                	// The minimum metric value for the data point.
                                	Minimum *float64
                                
                                	// The number of metric values that contributed to the aggregate value of this data
                                	// point.
                                	SampleCount *float64
                                
                                	// The sum of the metric values for the data point.
                                	Sum *float64
                                
                                	// The time stamp used for the data point.
                                	Timestamp *time.Time
                                
                                	// The standard unit for the data point.
                                	Unit StandardUnit
                                }

                                  Encapsulates the statistical data that CloudWatch computes from metric data.

                                  type Dimension

                                  type Dimension struct {
                                  
                                  	// The name of the dimension. Dimension names cannot contain blank spaces or
                                  	// non-ASCII characters.
                                  	//
                                  	// This member is required.
                                  	Name *string
                                  
                                  	// The value of the dimension. Dimension values cannot contain blank spaces or
                                  	// non-ASCII characters.
                                  	//
                                  	// This member is required.
                                  	Value *string
                                  }

                                    A dimension is a name/value pair that is part of the identity of a metric. You can assign up to 10 dimensions to a metric. Because dimensions are part of the unique identifier for a metric, whenever you add a unique name/value pair to one of your metrics, you are creating a new variation of that metric.

                                    type DimensionFilter

                                    type DimensionFilter struct {
                                    
                                    	// The dimension name to be matched.
                                    	//
                                    	// This member is required.
                                    	Name *string
                                    
                                    	// The value of the dimension to be matched.
                                    	Value *string
                                    }

                                      Represents filters for a dimension.

                                      type HistoryItemType

                                      type HistoryItemType string
                                      const (
                                      	HistoryItemTypeConfigurationUpdate HistoryItemType = "ConfigurationUpdate"
                                      	HistoryItemTypeStateUpdate         HistoryItemType = "StateUpdate"
                                      	HistoryItemTypeAction              HistoryItemType = "Action"
                                      )

                                        Enum values for HistoryItemType

                                        func (HistoryItemType) Values

                                        func (HistoryItemType) Values() []HistoryItemType

                                          Values returns all known values for HistoryItemType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                          type InsightRule

                                          type InsightRule struct {
                                          
                                          	// The definition of the rule, as a JSON object. The definition contains the
                                          	// keywords used to define contributors, the value to aggregate on if this rule
                                          	// returns a sum instead of a count, and the filters. For details on the valid
                                          	// syntax, see Contributor Insights Rule Syntax
                                          	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights-RuleSyntax.html).
                                          	//
                                          	// This member is required.
                                          	Definition *string
                                          
                                          	// The name of the rule.
                                          	//
                                          	// This member is required.
                                          	Name *string
                                          
                                          	// For rules that you create, this is always {"Name": "CloudWatchLogRule",
                                          	// "Version": 1}. For built-in rules, this is {"Name": "ServiceLogRule", "Version":
                                          	// 1}
                                          	//
                                          	// This member is required.
                                          	Schema *string
                                          
                                          	// Indicates whether the rule is enabled or disabled.
                                          	//
                                          	// This member is required.
                                          	State *string
                                          }

                                            This structure contains the definition for a Contributor Insights rule.

                                            type InsightRuleContributor

                                            type InsightRuleContributor struct {
                                            
                                            	// An approximation of the aggregate value that comes from this contributor.
                                            	//
                                            	// This member is required.
                                            	ApproximateAggregateValue *float64
                                            
                                            	// An array of the data points where this contributor is present. Only the data
                                            	// points when this contributor appeared are included in the array.
                                            	//
                                            	// This member is required.
                                            	Datapoints []InsightRuleContributorDatapoint
                                            
                                            	// One of the log entry field keywords that is used to define contributors for this
                                            	// rule.
                                            	//
                                            	// This member is required.
                                            	Keys []string
                                            }

                                              One of the unique contributors found by a Contributor Insights rule. If the rule contains multiple keys, then a unique contributor is a unique combination of values from all the keys in the rule. If the rule contains a single key, then each unique contributor is each unique value for this key. For more information, see GetInsightRuleReport (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetInsightRuleReport.html).

                                              type InsightRuleContributorDatapoint

                                              type InsightRuleContributorDatapoint struct {
                                              
                                              	// The approximate value that this contributor added during this timestamp.
                                              	//
                                              	// This member is required.
                                              	ApproximateValue *float64
                                              
                                              	// The timestamp of the data point.
                                              	//
                                              	// This member is required.
                                              	Timestamp *time.Time
                                              }

                                                One data point related to one contributor. For more information, see GetInsightRuleReport (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetInsightRuleReport.html) and InsightRuleContributor (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_InsightRuleContributor.html).

                                                type InsightRuleMetricDatapoint

                                                type InsightRuleMetricDatapoint struct {
                                                
                                                	// The timestamp of the data point.
                                                	//
                                                	// This member is required.
                                                	Timestamp *time.Time
                                                
                                                	// The average value from all contributors during the time period represented by
                                                	// that data point. This statistic is returned only if you included it in the
                                                	// Metrics array in your request.
                                                	Average *float64
                                                
                                                	// The maximum value provided by one contributor during this timestamp. Each
                                                	// timestamp is evaluated separately, so the identity of the max contributor could
                                                	// be different for each timestamp. This statistic is returned only if you included
                                                	// it in the Metrics array in your request.
                                                	MaxContributorValue *float64
                                                
                                                	// The maximum value from a single occurence from a single contributor during the
                                                	// time period represented by that data point. This statistic is returned only if
                                                	// you included it in the Metrics array in your request.
                                                	Maximum *float64
                                                
                                                	// The minimum value from a single contributor during the time period represented
                                                	// by that data point. This statistic is returned only if you included it in the
                                                	// Metrics array in your request.
                                                	Minimum *float64
                                                
                                                	// The number of occurrences that matched the rule during this data point. This
                                                	// statistic is returned only if you included it in the Metrics array in your
                                                	// request.
                                                	SampleCount *float64
                                                
                                                	// The sum of the values from all contributors during the time period represented
                                                	// by that data point. This statistic is returned only if you included it in the
                                                	// Metrics array in your request.
                                                	Sum *float64
                                                
                                                	// The number of unique contributors who published data during this timestamp. This
                                                	// statistic is returned only if you included it in the Metrics array in your
                                                	// request.
                                                	UniqueContributors *float64
                                                }

                                                  One data point from the metric time series returned in a Contributor Insights rule report. For more information, see GetInsightRuleReport (https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetInsightRuleReport.html).

                                                  type InternalServiceFault

                                                  type InternalServiceFault struct {
                                                  	Message *string
                                                  }

                                                    Request processing has failed due to some unknown error, exception, or failure.

                                                    func (*InternalServiceFault) Error

                                                    func (e *InternalServiceFault) Error() string

                                                    func (*InternalServiceFault) ErrorCode

                                                    func (e *InternalServiceFault) ErrorCode() string

                                                    func (*InternalServiceFault) ErrorFault

                                                    func (e *InternalServiceFault) ErrorFault() smithy.ErrorFault

                                                    func (*InternalServiceFault) ErrorMessage

                                                    func (e *InternalServiceFault) ErrorMessage() string

                                                    type InvalidFormatFault

                                                    type InvalidFormatFault struct {
                                                    	Message *string
                                                    }

                                                      Data was not syntactically valid JSON.

                                                      func (*InvalidFormatFault) Error

                                                      func (e *InvalidFormatFault) Error() string

                                                      func (*InvalidFormatFault) ErrorCode

                                                      func (e *InvalidFormatFault) ErrorCode() string

                                                      func (*InvalidFormatFault) ErrorFault

                                                      func (e *InvalidFormatFault) ErrorFault() smithy.ErrorFault

                                                      func (*InvalidFormatFault) ErrorMessage

                                                      func (e *InvalidFormatFault) ErrorMessage() string

                                                      type InvalidNextToken

                                                      type InvalidNextToken struct {
                                                      	Message *string
                                                      }

                                                        The next token specified is invalid.

                                                        func (*InvalidNextToken) Error

                                                        func (e *InvalidNextToken) Error() string

                                                        func (*InvalidNextToken) ErrorCode

                                                        func (e *InvalidNextToken) ErrorCode() string

                                                        func (*InvalidNextToken) ErrorFault

                                                        func (e *InvalidNextToken) ErrorFault() smithy.ErrorFault

                                                        func (*InvalidNextToken) ErrorMessage

                                                        func (e *InvalidNextToken) ErrorMessage() string

                                                        type InvalidParameterCombinationException

                                                        type InvalidParameterCombinationException struct {
                                                        	Message *string
                                                        }

                                                          Parameters were used together that cannot be used together.

                                                          func (*InvalidParameterCombinationException) Error

                                                          func (*InvalidParameterCombinationException) ErrorCode

                                                          func (*InvalidParameterCombinationException) ErrorFault

                                                          func (*InvalidParameterCombinationException) ErrorMessage

                                                          func (e *InvalidParameterCombinationException) ErrorMessage() string

                                                          type InvalidParameterValueException

                                                          type InvalidParameterValueException struct {
                                                          	Message *string
                                                          }

                                                            The value of an input parameter is bad or out-of-range.

                                                            func (*InvalidParameterValueException) Error

                                                            func (*InvalidParameterValueException) ErrorCode

                                                            func (e *InvalidParameterValueException) ErrorCode() string

                                                            func (*InvalidParameterValueException) ErrorFault

                                                            func (*InvalidParameterValueException) ErrorMessage

                                                            func (e *InvalidParameterValueException) ErrorMessage() string

                                                            type LimitExceededException

                                                            type LimitExceededException struct {
                                                            	Message *string
                                                            }

                                                              The operation exceeded one or more limits.

                                                              func (*LimitExceededException) Error

                                                              func (e *LimitExceededException) Error() string

                                                              func (*LimitExceededException) ErrorCode

                                                              func (e *LimitExceededException) ErrorCode() string

                                                              func (*LimitExceededException) ErrorFault

                                                              func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                              func (*LimitExceededException) ErrorMessage

                                                              func (e *LimitExceededException) ErrorMessage() string

                                                              type LimitExceededFault

                                                              type LimitExceededFault struct {
                                                              	Message *string
                                                              }

                                                                The quota for alarms for this customer has already been reached.

                                                                func (*LimitExceededFault) Error

                                                                func (e *LimitExceededFault) Error() string

                                                                func (*LimitExceededFault) ErrorCode

                                                                func (e *LimitExceededFault) ErrorCode() string

                                                                func (*LimitExceededFault) ErrorFault

                                                                func (e *LimitExceededFault) ErrorFault() smithy.ErrorFault

                                                                func (*LimitExceededFault) ErrorMessage

                                                                func (e *LimitExceededFault) ErrorMessage() string

                                                                type MessageData

                                                                type MessageData struct {
                                                                
                                                                	// The error code or status code associated with the message.
                                                                	Code *string
                                                                
                                                                	// The message text.
                                                                	Value *string
                                                                }

                                                                  A message returned by the GetMetricDataAPI, including a code and a description.

                                                                  type Metric

                                                                  type Metric struct {
                                                                  
                                                                  	// The dimensions for the metric.
                                                                  	Dimensions []Dimension
                                                                  
                                                                  	// The name of the metric. This is a required field.
                                                                  	MetricName *string
                                                                  
                                                                  	// The namespace of the metric.
                                                                  	Namespace *string
                                                                  }

                                                                    Represents a specific metric.

                                                                    type MetricAlarm

                                                                    type MetricAlarm struct {
                                                                    
                                                                    	// Indicates whether actions should be executed during any changes to the alarm
                                                                    	// state.
                                                                    	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).
                                                                    	AlarmActions []string
                                                                    
                                                                    	// The Amazon Resource Name (ARN) of the alarm.
                                                                    	AlarmArn *string
                                                                    
                                                                    	// The time stamp of the last update to the alarm configuration.
                                                                    	AlarmConfigurationUpdatedTimestamp *time.Time
                                                                    
                                                                    	// The description of the alarm.
                                                                    	AlarmDescription *string
                                                                    
                                                                    	// The name of the alarm.
                                                                    	AlarmName *string
                                                                    
                                                                    	// The arithmetic operation to use when comparing the specified statistic and
                                                                    	// threshold. The specified statistic value is used as the first operand.
                                                                    	ComparisonOperator ComparisonOperator
                                                                    
                                                                    	// The number of data points that must be breaching to trigger the alarm.
                                                                    	DatapointsToAlarm *int32
                                                                    
                                                                    	// The dimensions for the metric associated with the alarm.
                                                                    	Dimensions []Dimension
                                                                    
                                                                    	// Used only for alarms based on percentiles. If ignore, the alarm state does not
                                                                    	// change during periods with too few data points to be statistically significant.
                                                                    	// If evaluate or this parameter is not used, the alarm is always evaluated and
                                                                    	// possibly changes state no matter how many data points are available.
                                                                    	EvaluateLowSampleCountPercentile *string
                                                                    
                                                                    	// The number of periods over which data is compared to the specified threshold.
                                                                    	EvaluationPeriods *int32
                                                                    
                                                                    	// The percentile statistic for the metric associated with the alarm. Specify a
                                                                    	// value between p0.0 and p100.
                                                                    	ExtendedStatistic *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).
                                                                    	InsufficientDataActions []string
                                                                    
                                                                    	// The name of the metric associated with the alarm, if this is an alarm based on a
                                                                    	// single metric.
                                                                    	MetricName *string
                                                                    
                                                                    	// An array of MetricDataQuery structures, used in an alarm based on a metric math
                                                                    	// expression. Each structure either retrieves a metric or performs a math
                                                                    	// expression. One item in the Metrics array is the math expression that the alarm
                                                                    	// watches. This expression by designated by having ReturnData set to true.
                                                                    	Metrics []MetricDataQuery
                                                                    
                                                                    	// The namespace of the metric associated with the alarm.
                                                                    	Namespace *string
                                                                    
                                                                    	// The actions to execute when this alarm transitions to the OK state from any
                                                                    	// other state. Each action is specified as an Amazon Resource Name (ARN).
                                                                    	OKActions []string
                                                                    
                                                                    	// The period, in seconds, over which the statistic is applied.
                                                                    	Period *int32
                                                                    
                                                                    	// An explanation for the alarm state, in text format.
                                                                    	StateReason *string
                                                                    
                                                                    	// An explanation for the alarm state, in JSON format.
                                                                    	StateReasonData *string
                                                                    
                                                                    	// The time stamp of the last update to the alarm state.
                                                                    	StateUpdatedTimestamp *time.Time
                                                                    
                                                                    	// The state value for the alarm.
                                                                    	StateValue StateValue
                                                                    
                                                                    	// The statistic for the metric associated with the alarm, other than percentile.
                                                                    	// For percentile statistics, use ExtendedStatistic.
                                                                    	Statistic Statistic
                                                                    
                                                                    	// The value to compare with the specified statistic.
                                                                    	Threshold *float64
                                                                    
                                                                    	// In an alarm based on an anomaly detection model, this is the ID of the
                                                                    	// ANOMALY_DETECTION_BAND function used as the threshold for the alarm.
                                                                    	ThresholdMetricId *string
                                                                    
                                                                    	// Sets how this alarm is to handle missing data points. If this parameter is
                                                                    	// omitted, the default behavior of missing is used.
                                                                    	TreatMissingData *string
                                                                    
                                                                    	// The unit of the metric associated with the alarm.
                                                                    	Unit StandardUnit
                                                                    }

                                                                      The details about a metric alarm.

                                                                      type MetricDataQuery

                                                                      type MetricDataQuery struct {
                                                                      
                                                                      	// A short name used to tie this object to the results in the response. This name
                                                                      	// must be unique within a single call to GetMetricData. If you are performing math
                                                                      	// expressions on this set of data, this name represents that data and can serve as
                                                                      	// a variable in the mathematical expression. The valid characters are letters,
                                                                      	// numbers, and underscore. The first character must be a lowercase letter.
                                                                      	//
                                                                      	// This member is required.
                                                                      	Id *string
                                                                      
                                                                      	// The math expression to be performed on the returned data, if this object is
                                                                      	// performing a math expression. This expression can use the Id of the other
                                                                      	// metrics to refer to those metrics, and can also use the Id of other expressions
                                                                      	// to use the result of those expressions. For more information about metric math
                                                                      	// expressions, see Metric Math Syntax and Functions
                                                                      	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax)
                                                                      	// in the Amazon CloudWatch User Guide. Within each MetricDataQuery object, you
                                                                      	// must specify either Expression or MetricStat but not both.
                                                                      	Expression *string
                                                                      
                                                                      	// A human-readable label for this metric or expression. This is especially useful
                                                                      	// if this is an expression, so that you know what the value represents. If the
                                                                      	// metric or expression is shown in a CloudWatch dashboard widget, the label is
                                                                      	// shown. If Label is omitted, CloudWatch generates a default.
                                                                      	Label *string
                                                                      
                                                                      	// The metric to be returned, along with statistics, period, and units. Use this
                                                                      	// parameter only if this object is retrieving a metric and not performing a math
                                                                      	// expression on returned data. Within one MetricDataQuery object, you must specify
                                                                      	// either Expression or MetricStat but not both.
                                                                      	MetricStat *MetricStat
                                                                      
                                                                      	// 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
                                                                      	// operation that includes a StorageResolution of 1 second.
                                                                      	Period *int32
                                                                      
                                                                      	// When used in GetMetricData, this option indicates whether to return the
                                                                      	// timestamps and raw data values of this metric. If you are performing this call
                                                                      	// just to do math expressions and do not also need the raw data returned, you can
                                                                      	// specify False. If you omit this, the default of True is used. When used in
                                                                      	// PutMetricAlarm, specify True for the one expression result to use as the alarm.
                                                                      	// For all other metrics and expressions in the same PutMetricAlarm operation,
                                                                      	// specify ReturnData as False.
                                                                      	ReturnData *bool
                                                                      }

                                                                        This structure is used in both GetMetricData and PutMetricAlarm. The supported use of this structure is different for those two operations. When used in GetMetricData, it indicates the metric data to return, and whether this call is just retrieving a batch set of data for one metric, or is performing a math expression on metric data. A single GetMetricData call can include up to 500 MetricDataQuery structures. When used in PutMetricAlarm, it enables you to create an alarm based on a metric math expression. Each MetricDataQuery in the array specifies either a metric to retrieve, or a math expression to be performed on retrieved metrics. A single PutMetricAlarm call can include up to 20 MetricDataQuery structures in the array. The 20 structures can include as many as 10 structures that contain a MetricStat parameter to retrieve a metric, and as many as 10 structures that contain the Expression parameter to perform a math expression. Of those Expression structures, one must have True as the value for ReturnData. The result of this expression is the value the alarm watches. Any expression used in a PutMetricAlarm operation must return a single time series. For more information, see Metric Math Syntax and Functions (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax) in the Amazon CloudWatch User Guide. Some of the parameters of this structure also have different uses whether you are using this structure in a GetMetricData operation or a PutMetricAlarm operation. These differences are explained in the following parameter list.

                                                                        type MetricDataResult

                                                                        type MetricDataResult struct {
                                                                        
                                                                        	// The short name you specified to represent this metric.
                                                                        	Id *string
                                                                        
                                                                        	// The human-readable label associated with the data.
                                                                        	Label *string
                                                                        
                                                                        	// A list of messages with additional information about the data returned.
                                                                        	Messages []MessageData
                                                                        
                                                                        	// The status of the returned data. Complete indicates that all data points in the
                                                                        	// requested time range were returned. PartialData means that an incomplete set of
                                                                        	// data points were returned. You can use the NextToken value that was returned and
                                                                        	// repeat your request to get more data points. NextToken is not returned if you
                                                                        	// are performing a math expression. InternalError indicates that an error
                                                                        	// occurred. Retry your request using NextToken, if present.
                                                                        	StatusCode StatusCode
                                                                        
                                                                        	// The timestamps for the data points, formatted in Unix timestamp format. The
                                                                        	// number of timestamps always matches the number of values and the value for
                                                                        	// Timestamps[x] is Values[x].
                                                                        	Timestamps []time.Time
                                                                        
                                                                        	// The data points for the metric corresponding to Timestamps. The number of values
                                                                        	// always matches the number of timestamps and the timestamp for Values[x] is
                                                                        	// Timestamps[x].
                                                                        	Values []float64
                                                                        }

                                                                          A GetMetricData call returns an array of MetricDataResult structures. Each of these structures includes the data points for that metric, along with the timestamps of those data points and other identifying information.

                                                                          type MetricDatum

                                                                          type MetricDatum struct {
                                                                          
                                                                          	// The name of the metric.
                                                                          	//
                                                                          	// This member is required.
                                                                          	MetricName *string
                                                                          
                                                                          	// Array of numbers that is used along with the Values array. Each number in the
                                                                          	// Count array is the number of times the corresponding value in the Values array
                                                                          	// occurred during the period. If you omit the Counts array, the default of 1 is
                                                                          	// used as the value for each count. If you include a Counts array, it must include
                                                                          	// the same amount of values as the Values array.
                                                                          	Counts []float64
                                                                          
                                                                          	// The dimensions associated with the metric.
                                                                          	Dimensions []Dimension
                                                                          
                                                                          	// The statistical values for the metric.
                                                                          	StatisticValues *StatisticSet
                                                                          
                                                                          	// Valid values are 1 and 60. Setting this to 1 specifies this metric as a
                                                                          	// high-resolution metric, so that CloudWatch stores the metric with sub-minute
                                                                          	// resolution down to one second. Setting this to 60 specifies this metric as a
                                                                          	// regular-resolution metric, which CloudWatch stores at 1-minute resolution.
                                                                          	// Currently, high resolution is available only for custom metrics. For more
                                                                          	// information about high-resolution metrics, see High-Resolution Metrics
                                                                          	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#high-resolution-metrics)
                                                                          	// in the Amazon CloudWatch User Guide. This field is optional, if you do not
                                                                          	// specify it the default of 60 is used.
                                                                          	StorageResolution *int32
                                                                          
                                                                          	// The time the metric data was received, expressed as the number of milliseconds
                                                                          	// since Jan 1, 1970 00:00:00 UTC.
                                                                          	Timestamp *time.Time
                                                                          
                                                                          	// When you are using a Put operation, this defines what unit you want to use when
                                                                          	// storing the metric. In a Get operation, this displays the unit that is used for
                                                                          	// the metric.
                                                                          	Unit StandardUnit
                                                                          
                                                                          	// The value for the metric. Although the parameter accepts numbers of type Double,
                                                                          	// CloudWatch rejects values that are either too small or too large. Values must be
                                                                          	// in the range of -2^360 to 2^360. In addition, special values (for example, NaN,
                                                                          	// +Infinity, -Infinity) are not supported.
                                                                          	Value *float64
                                                                          
                                                                          	// Array of numbers representing the values for the metric during the period. Each
                                                                          	// unique value is listed just once in this array, and the corresponding number in
                                                                          	// the Counts array specifies the number of times that value occurred during the
                                                                          	// period. You can include up to 150 unique values in each PutMetricData action
                                                                          	// that specifies a Values array. Although the Values array accepts numbers of type
                                                                          	// Double, CloudWatch rejects values that are either too small or too large. Values
                                                                          	// must be in the range of -2^360 to 2^360. In addition, special values (for
                                                                          	// example, NaN, +Infinity, -Infinity) are not supported.
                                                                          	Values []float64
                                                                          }

                                                                            Encapsulates the information sent to either create a metric or add new values to be aggregated into an existing metric.

                                                                            type MetricStat

                                                                            type MetricStat struct {
                                                                            
                                                                            	// The metric to return, including the metric name, namespace, and dimensions.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Metric *Metric
                                                                            
                                                                            	// 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).
                                                                            	//
                                                                            	// This member is required.
                                                                            	Period *int32
                                                                            
                                                                            	// The statistic to return. It can include any CloudWatch statistic or extended
                                                                            	// statistic.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Stat *string
                                                                            
                                                                            	// When you are using a Put operation, this defines what unit you want to use when
                                                                            	// storing the metric. In a Get operation, if you omit Unit then 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 StandardUnit
                                                                            }

                                                                              This structure defines the metric to be returned, along with the statistics, period, and units.

                                                                              type MissingRequiredParameterException

                                                                              type MissingRequiredParameterException struct {
                                                                              	Message *string
                                                                              }

                                                                                An input parameter that is required is missing.

                                                                                func (*MissingRequiredParameterException) Error

                                                                                func (*MissingRequiredParameterException) ErrorCode

                                                                                func (*MissingRequiredParameterException) ErrorFault

                                                                                func (*MissingRequiredParameterException) ErrorMessage

                                                                                func (e *MissingRequiredParameterException) ErrorMessage() string

                                                                                type PartialFailure

                                                                                type PartialFailure struct {
                                                                                
                                                                                	// The type of error.
                                                                                	ExceptionType *string
                                                                                
                                                                                	// The code of the error.
                                                                                	FailureCode *string
                                                                                
                                                                                	// A description of the error.
                                                                                	FailureDescription *string
                                                                                
                                                                                	// The specified rule that could not be deleted.
                                                                                	FailureResource *string
                                                                                }

                                                                                  This array is empty if the API operation was successful for all the rules specified in the request. If the operation could not process one of the rules, the following data is returned for each of those rules.

                                                                                  type Range

                                                                                  type Range struct {
                                                                                  
                                                                                  	// The end time of the range to exclude. The format is yyyy-MM-dd'T'HH:mm:ss. For
                                                                                  	// example, 2019-07-01T23:59:59.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	EndTime *time.Time
                                                                                  
                                                                                  	// The start time of the range to exclude. The format is yyyy-MM-dd'T'HH:mm:ss. For
                                                                                  	// example, 2019-07-01T23:59:59.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	StartTime *time.Time
                                                                                  }

                                                                                    Specifies one range of days or times to exclude from use for training an anomaly detection model.

                                                                                    type RecentlyActive

                                                                                    type RecentlyActive string
                                                                                    const (
                                                                                    	RecentlyActivePt3h RecentlyActive = "PT3H"
                                                                                    )

                                                                                      Enum values for RecentlyActive

                                                                                      func (RecentlyActive) Values

                                                                                      func (RecentlyActive) Values() []RecentlyActive

                                                                                        Values returns all known values for RecentlyActive. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                        type ResourceNotFound

                                                                                        type ResourceNotFound struct {
                                                                                        	Message *string
                                                                                        }

                                                                                          The named resource does not exist.

                                                                                          func (*ResourceNotFound) Error

                                                                                          func (e *ResourceNotFound) Error() string

                                                                                          func (*ResourceNotFound) ErrorCode

                                                                                          func (e *ResourceNotFound) ErrorCode() string

                                                                                          func (*ResourceNotFound) ErrorFault

                                                                                          func (e *ResourceNotFound) ErrorFault() smithy.ErrorFault

                                                                                          func (*ResourceNotFound) ErrorMessage

                                                                                          func (e *ResourceNotFound) ErrorMessage() string

                                                                                          type ResourceNotFoundException

                                                                                          type ResourceNotFoundException struct {
                                                                                          	Message *string
                                                                                          
                                                                                          	ResourceType *string
                                                                                          	ResourceId   *string
                                                                                          }

                                                                                            The named resource does not exist.

                                                                                            func (*ResourceNotFoundException) Error

                                                                                            func (e *ResourceNotFoundException) Error() string

                                                                                            func (*ResourceNotFoundException) ErrorCode

                                                                                            func (e *ResourceNotFoundException) ErrorCode() string

                                                                                            func (*ResourceNotFoundException) ErrorFault

                                                                                            func (*ResourceNotFoundException) ErrorMessage

                                                                                            func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                            type ScanBy

                                                                                            type ScanBy string
                                                                                            const (
                                                                                            	ScanByTimestampDescending ScanBy = "TimestampDescending"
                                                                                            	ScanByTimestampAscending  ScanBy = "TimestampAscending"
                                                                                            )

                                                                                              Enum values for ScanBy

                                                                                              func (ScanBy) Values

                                                                                              func (ScanBy) Values() []ScanBy

                                                                                                Values returns all known values for ScanBy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                type StandardUnit

                                                                                                type StandardUnit string
                                                                                                const (
                                                                                                	StandardUnitSeconds         StandardUnit = "Seconds"
                                                                                                	StandardUnitMicroseconds    StandardUnit = "Microseconds"
                                                                                                	StandardUnitMilliseconds    StandardUnit = "Milliseconds"
                                                                                                	StandardUnitBytes           StandardUnit = "Bytes"
                                                                                                	StandardUnitKilobytes       StandardUnit = "Kilobytes"
                                                                                                	StandardUnitMegabytes       StandardUnit = "Megabytes"
                                                                                                	StandardUnitGigabytes       StandardUnit = "Gigabytes"
                                                                                                	StandardUnitTerabytes       StandardUnit = "Terabytes"
                                                                                                	StandardUnitBits            StandardUnit = "Bits"
                                                                                                	StandardUnitKilobits        StandardUnit = "Kilobits"
                                                                                                	StandardUnitMegabits        StandardUnit = "Megabits"
                                                                                                	StandardUnitGigabits        StandardUnit = "Gigabits"
                                                                                                	StandardUnitTerabits        StandardUnit = "Terabits"
                                                                                                	StandardUnitPercent         StandardUnit = "Percent"
                                                                                                	StandardUnitCount           StandardUnit = "Count"
                                                                                                	StandardUnitBytesSecond     StandardUnit = "Bytes/Second"
                                                                                                	StandardUnitKilobytesSecond StandardUnit = "Kilobytes/Second"
                                                                                                	StandardUnitMegabytesSecond StandardUnit = "Megabytes/Second"
                                                                                                	StandardUnitGigabytesSecond StandardUnit = "Gigabytes/Second"
                                                                                                	StandardUnitTerabytesSecond StandardUnit = "Terabytes/Second"
                                                                                                	StandardUnitBitsSecond      StandardUnit = "Bits/Second"
                                                                                                	StandardUnitKilobitsSecond  StandardUnit = "Kilobits/Second"
                                                                                                	StandardUnitMegabitsSecond  StandardUnit = "Megabits/Second"
                                                                                                	StandardUnitGigabitsSecond  StandardUnit = "Gigabits/Second"
                                                                                                	StandardUnitTerabitsSecond  StandardUnit = "Terabits/Second"
                                                                                                	StandardUnitCountSecond     StandardUnit = "Count/Second"
                                                                                                	StandardUnitNone            StandardUnit = "None"
                                                                                                )

                                                                                                  Enum values for StandardUnit

                                                                                                  func (StandardUnit) Values

                                                                                                  func (StandardUnit) Values() []StandardUnit

                                                                                                    Values returns all known values for StandardUnit. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                    type StateValue

                                                                                                    type StateValue string
                                                                                                    const (
                                                                                                    	StateValueOk               StateValue = "OK"
                                                                                                    	StateValueAlarm            StateValue = "ALARM"
                                                                                                    	StateValueInsufficientData StateValue = "INSUFFICIENT_DATA"
                                                                                                    )

                                                                                                      Enum values for StateValue

                                                                                                      func (StateValue) Values

                                                                                                      func (StateValue) Values() []StateValue

                                                                                                        Values returns all known values for StateValue. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                        type Statistic

                                                                                                        type Statistic string
                                                                                                        const (
                                                                                                        	StatisticSampleCount Statistic = "SampleCount"
                                                                                                        	StatisticAverage     Statistic = "Average"
                                                                                                        	StatisticSum         Statistic = "Sum"
                                                                                                        	StatisticMinimum     Statistic = "Minimum"
                                                                                                        	StatisticMaximum     Statistic = "Maximum"
                                                                                                        )

                                                                                                          Enum values for Statistic

                                                                                                          func (Statistic) Values

                                                                                                          func (Statistic) Values() []Statistic

                                                                                                            Values returns all known values for Statistic. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                            type StatisticSet

                                                                                                            type StatisticSet struct {
                                                                                                            
                                                                                                            	// The maximum value of the sample set.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	Maximum *float64
                                                                                                            
                                                                                                            	// The minimum value of the sample set.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	Minimum *float64
                                                                                                            
                                                                                                            	// The number of samples used for the statistic set.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	SampleCount *float64
                                                                                                            
                                                                                                            	// The sum of values for the sample set.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	Sum *float64
                                                                                                            }

                                                                                                              Represents a set of statistics that describes a specific metric.

                                                                                                              type StatusCode

                                                                                                              type StatusCode string
                                                                                                              const (
                                                                                                              	StatusCodeComplete      StatusCode = "Complete"
                                                                                                              	StatusCodeInternalError StatusCode = "InternalError"
                                                                                                              	StatusCodePartialData   StatusCode = "PartialData"
                                                                                                              )

                                                                                                                Enum values for StatusCode

                                                                                                                func (StatusCode) Values

                                                                                                                func (StatusCode) Values() []StatusCode

                                                                                                                  Values returns all known values for StatusCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                  type Tag

                                                                                                                  type Tag struct {
                                                                                                                  
                                                                                                                  	// A string that you can use to assign a value. The combination of tag keys and
                                                                                                                  	// values can help you organize and categorize your resources.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	Key *string
                                                                                                                  
                                                                                                                  	// The value for the specified tag key.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	Value *string
                                                                                                                  }

                                                                                                                    A key-value pair associated with a CloudWatch resource.