import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
import { CloudWatchServiceException as __BaseException } from "./CloudWatchServiceException";
export declare const ActionsSuppressedBy: {
  readonly Alarm: "Alarm";
  readonly ExtensionPeriod: "ExtensionPeriod";
  readonly WaitPeriod: "WaitPeriod";
};
export type ActionsSuppressedBy =
  (typeof ActionsSuppressedBy)[keyof typeof ActionsSuppressedBy];
export declare const AlarmType: {
  readonly CompositeAlarm: "CompositeAlarm";
  readonly MetricAlarm: "MetricAlarm";
};
export type AlarmType = (typeof AlarmType)[keyof typeof AlarmType];
export declare const HistoryItemType: {
  readonly Action: "Action";
  readonly ConfigurationUpdate: "ConfigurationUpdate";
  readonly StateUpdate: "StateUpdate";
};
export type HistoryItemType =
  (typeof HistoryItemType)[keyof typeof HistoryItemType];
export interface AlarmHistoryItem {
  AlarmName?: string;
  AlarmType?: AlarmType;
  Timestamp?: Date;
  HistoryItemType?: HistoryItemType;
  HistorySummary?: string;
  HistoryData?: string;
}
export interface Range {
  StartTime: Date | undefined;
  EndTime: Date | undefined;
}
export interface AnomalyDetectorConfiguration {
  ExcludedTimeRanges?: Range[];
  MetricTimezone?: string;
}
export interface Dimension {
  Name: string | undefined;
  Value: string | undefined;
}
export interface Metric {
  Namespace?: string;
  MetricName?: string;
  Dimensions?: Dimension[];
}
export declare const StandardUnit: {
  readonly Bits: "Bits";
  readonly Bits_Second: "Bits/Second";
  readonly Bytes: "Bytes";
  readonly Bytes_Second: "Bytes/Second";
  readonly Count: "Count";
  readonly Count_Second: "Count/Second";
  readonly Gigabits: "Gigabits";
  readonly Gigabits_Second: "Gigabits/Second";
  readonly Gigabytes: "Gigabytes";
  readonly Gigabytes_Second: "Gigabytes/Second";
  readonly Kilobits: "Kilobits";
  readonly Kilobits_Second: "Kilobits/Second";
  readonly Kilobytes: "Kilobytes";
  readonly Kilobytes_Second: "Kilobytes/Second";
  readonly Megabits: "Megabits";
  readonly Megabits_Second: "Megabits/Second";
  readonly Megabytes: "Megabytes";
  readonly Megabytes_Second: "Megabytes/Second";
  readonly Microseconds: "Microseconds";
  readonly Milliseconds: "Milliseconds";
  readonly None: "None";
  readonly Percent: "Percent";
  readonly Seconds: "Seconds";
  readonly Terabits: "Terabits";
  readonly Terabits_Second: "Terabits/Second";
  readonly Terabytes: "Terabytes";
  readonly Terabytes_Second: "Terabytes/Second";
};
export type StandardUnit = (typeof StandardUnit)[keyof typeof StandardUnit];
export interface MetricStat {
  Metric: Metric | undefined;
  Period: number | undefined;
  Stat: string | undefined;
  Unit?: StandardUnit;
}
export interface MetricDataQuery {
  Id: string | undefined;
  MetricStat?: MetricStat;
  Expression?: string;
  Label?: string;
  ReturnData?: boolean;
  Period?: number;
  AccountId?: string;
}
export interface MetricMathAnomalyDetector {
  MetricDataQueries?: MetricDataQuery[];
}
export interface SingleMetricAnomalyDetector {
  Namespace?: string;
  MetricName?: string;
  Dimensions?: Dimension[];
  Stat?: string;
}
export declare const AnomalyDetectorStateValue: {
  readonly PENDING_TRAINING: "PENDING_TRAINING";
  readonly TRAINED: "TRAINED";
  readonly TRAINED_INSUFFICIENT_DATA: "TRAINED_INSUFFICIENT_DATA";
};
export type AnomalyDetectorStateValue =
  (typeof AnomalyDetectorStateValue)[keyof typeof AnomalyDetectorStateValue];
export interface AnomalyDetector {
  Namespace?: string;
  MetricName?: string;
  Dimensions?: Dimension[];
  Stat?: string;
  Configuration?: AnomalyDetectorConfiguration;
  StateValue?: AnomalyDetectorStateValue;
  SingleMetricAnomalyDetector?: SingleMetricAnomalyDetector;
  MetricMathAnomalyDetector?: MetricMathAnomalyDetector;
}
export declare const AnomalyDetectorType: {
  readonly METRIC_MATH: "METRIC_MATH";
  readonly SINGLE_METRIC: "SINGLE_METRIC";
};
export type AnomalyDetectorType =
  (typeof AnomalyDetectorType)[keyof typeof AnomalyDetectorType];
export interface PartialFailure {
  FailureResource?: string;
  ExceptionType?: string;
  FailureCode?: string;
  FailureDescription?: string;
}
export declare const ComparisonOperator: {
  readonly GreaterThanOrEqualToThreshold: "GreaterThanOrEqualToThreshold";
  readonly GreaterThanThreshold: "GreaterThanThreshold";
  readonly GreaterThanUpperThreshold: "GreaterThanUpperThreshold";
  readonly LessThanLowerOrGreaterThanUpperThreshold: "LessThanLowerOrGreaterThanUpperThreshold";
  readonly LessThanLowerThreshold: "LessThanLowerThreshold";
  readonly LessThanOrEqualToThreshold: "LessThanOrEqualToThreshold";
  readonly LessThanThreshold: "LessThanThreshold";
};
export type ComparisonOperator =
  (typeof ComparisonOperator)[keyof typeof ComparisonOperator];
export declare const StateValue: {
  readonly ALARM: "ALARM";
  readonly INSUFFICIENT_DATA: "INSUFFICIENT_DATA";
  readonly OK: "OK";
};
export type StateValue = (typeof StateValue)[keyof typeof StateValue];
export interface CompositeAlarm {
  ActionsEnabled?: boolean;
  AlarmActions?: string[];
  AlarmArn?: string;
  AlarmConfigurationUpdatedTimestamp?: Date;
  AlarmDescription?: string;
  AlarmName?: string;
  AlarmRule?: string;
  InsufficientDataActions?: string[];
  OKActions?: string[];
  StateReason?: string;
  StateReasonData?: string;
  StateUpdatedTimestamp?: Date;
  StateValue?: StateValue;
  StateTransitionedTimestamp?: Date;
  ActionsSuppressedBy?: ActionsSuppressedBy;
  ActionsSuppressedReason?: string;
  ActionsSuppressor?: string;
  ActionsSuppressorWaitPeriod?: number;
  ActionsSuppressorExtensionPeriod?: number;
}
export declare class ConcurrentModificationException extends __BaseException {
  readonly name: "ConcurrentModificationException";
  readonly $fault: "client";
  Message?: string;
  constructor(
    opts: __ExceptionOptionType<
      ConcurrentModificationException,
      __BaseException
    >
  );
}
export interface DashboardEntry {
  DashboardName?: string;
  DashboardArn?: string;
  LastModified?: Date;
  Size?: number;
}
export interface DashboardValidationMessage {
  DataPath?: string;
  Message?: string;
}
export declare class DashboardInvalidInputError extends __BaseException {
  readonly name: "DashboardInvalidInputError";
  readonly $fault: "client";
  dashboardValidationMessages?: DashboardValidationMessage[];
  constructor(
    opts: __ExceptionOptionType<DashboardInvalidInputError, __BaseException>
  );
}
export declare class DashboardNotFoundError extends __BaseException {
  readonly name: "DashboardNotFoundError";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<DashboardNotFoundError, __BaseException>
  );
}
export interface Datapoint {
  Timestamp?: Date;
  SampleCount?: number;
  Average?: number;
  Sum?: number;
  Minimum?: number;
  Maximum?: number;
  Unit?: StandardUnit;
  ExtendedStatistics?: Record<string, number>;
}
export interface DeleteAlarmsInput {
  AlarmNames: string[] | undefined;
}
export declare class ResourceNotFound extends __BaseException {
  readonly name: "ResourceNotFound";
  readonly $fault: "client";
  constructor(opts: __ExceptionOptionType<ResourceNotFound, __BaseException>);
}
export interface DeleteAnomalyDetectorInput {
  Namespace?: string;
  MetricName?: string;
  Dimensions?: Dimension[];
  Stat?: string;
  SingleMetricAnomalyDetector?: SingleMetricAnomalyDetector;
  MetricMathAnomalyDetector?: MetricMathAnomalyDetector;
}
export interface DeleteAnomalyDetectorOutput {}
export declare class InternalServiceFault extends __BaseException {
  readonly name: "InternalServiceFault";
  readonly $fault: "server";
  Message?: string;
  constructor(
    opts: __ExceptionOptionType<InternalServiceFault, __BaseException>
  );
}
export declare class InvalidParameterCombinationException extends __BaseException {
  readonly name: "InvalidParameterCombinationException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<
      InvalidParameterCombinationException,
      __BaseException
    >
  );
}
export declare class InvalidParameterValueException extends __BaseException {
  readonly name: "InvalidParameterValueException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>
  );
}
export declare class MissingRequiredParameterException extends __BaseException {
  readonly name: "MissingRequiredParameterException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<
      MissingRequiredParameterException,
      __BaseException
    >
  );
}
export declare class ResourceNotFoundException extends __BaseException {
  readonly name: "ResourceNotFoundException";
  readonly $fault: "client";
  ResourceType?: string;
  ResourceId?: string;
  Message?: string;
  constructor(
    opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>
  );
}
export interface DeleteDashboardsInput {
  DashboardNames: string[] | undefined;
}
export interface DeleteDashboardsOutput {}
export interface DeleteInsightRulesInput {
  RuleNames: string[] | undefined;
}
export interface DeleteInsightRulesOutput {
  Failures?: PartialFailure[];
}
export interface DeleteMetricStreamInput {
  Name: string | undefined;
}
export interface DeleteMetricStreamOutput {}
export declare const ScanBy: {
  readonly TIMESTAMP_ASCENDING: "TimestampAscending";
  readonly TIMESTAMP_DESCENDING: "TimestampDescending";
};
export type ScanBy = (typeof ScanBy)[keyof typeof ScanBy];
export interface DescribeAlarmHistoryInput {
  AlarmName?: string;
  AlarmTypes?: AlarmType[];
  HistoryItemType?: HistoryItemType;
  StartDate?: Date;
  EndDate?: Date;
  MaxRecords?: number;
  NextToken?: string;
  ScanBy?: ScanBy;
}
export interface DescribeAlarmHistoryOutput {
  AlarmHistoryItems?: AlarmHistoryItem[];
  NextToken?: string;
}
export declare class InvalidNextToken extends __BaseException {
  readonly name: "InvalidNextToken";
  readonly $fault: "client";
  constructor(opts: __ExceptionOptionType<InvalidNextToken, __BaseException>);
}
export interface DescribeAlarmsInput {
  AlarmNames?: string[];
  AlarmNamePrefix?: string;
  AlarmTypes?: AlarmType[];
  ChildrenOfAlarmName?: string;
  ParentsOfAlarmName?: string;
  StateValue?: StateValue;
  ActionPrefix?: string;
  MaxRecords?: number;
  NextToken?: string;
}
export declare const EvaluationState: {
  readonly PARTIAL_DATA: "PARTIAL_DATA";
};
export type EvaluationState =
  (typeof EvaluationState)[keyof typeof EvaluationState];
export declare const Statistic: {
  readonly Average: "Average";
  readonly Maximum: "Maximum";
  readonly Minimum: "Minimum";
  readonly SampleCount: "SampleCount";
  readonly Sum: "Sum";
};
export type Statistic = (typeof Statistic)[keyof typeof Statistic];
export interface MetricAlarm {
  AlarmName?: string;
  AlarmArn?: string;
  AlarmDescription?: string;
  AlarmConfigurationUpdatedTimestamp?: Date;
  ActionsEnabled?: boolean;
  OKActions?: string[];
  AlarmActions?: string[];
  InsufficientDataActions?: string[];
  StateValue?: StateValue;
  StateReason?: string;
  StateReasonData?: string;
  StateUpdatedTimestamp?: Date;
  MetricName?: string;
  Namespace?: string;
  Statistic?: Statistic;
  ExtendedStatistic?: string;
  Dimensions?: Dimension[];
  Period?: number;
  Unit?: StandardUnit;
  EvaluationPeriods?: number;
  DatapointsToAlarm?: number;
  Threshold?: number;
  ComparisonOperator?: ComparisonOperator;
  TreatMissingData?: string;
  EvaluateLowSampleCountPercentile?: string;
  Metrics?: MetricDataQuery[];
  ThresholdMetricId?: string;
  EvaluationState?: EvaluationState;
  StateTransitionedTimestamp?: Date;
}
export interface DescribeAlarmsOutput {
  CompositeAlarms?: CompositeAlarm[];
  MetricAlarms?: MetricAlarm[];
  NextToken?: string;
}
export interface DescribeAlarmsForMetricInput {
  MetricName: string | undefined;
  Namespace: string | undefined;
  Statistic?: Statistic;
  ExtendedStatistic?: string;
  Dimensions?: Dimension[];
  Period?: number;
  Unit?: StandardUnit;
}
export interface DescribeAlarmsForMetricOutput {
  MetricAlarms?: MetricAlarm[];
}
export interface DescribeAnomalyDetectorsInput {
  NextToken?: string;
  MaxResults?: number;
  Namespace?: string;
  MetricName?: string;
  Dimensions?: Dimension[];
  AnomalyDetectorTypes?: AnomalyDetectorType[];
}
export interface DescribeAnomalyDetectorsOutput {
  AnomalyDetectors?: AnomalyDetector[];
  NextToken?: string;
}
export interface DescribeInsightRulesInput {
  NextToken?: string;
  MaxResults?: number;
}
export interface InsightRule {
  Name: string | undefined;
  State: string | undefined;
  Schema: string | undefined;
  Definition: string | undefined;
  ManagedRule?: boolean;
}
export interface DescribeInsightRulesOutput {
  NextToken?: string;
  InsightRules?: InsightRule[];
}
export interface DimensionFilter {
  Name: string | undefined;
  Value?: string;
}
export interface DisableAlarmActionsInput {
  AlarmNames: string[] | undefined;
}
export interface DisableInsightRulesInput {
  RuleNames: string[] | undefined;
}
export interface DisableInsightRulesOutput {
  Failures?: PartialFailure[];
}
export interface EnableAlarmActionsInput {
  AlarmNames: string[] | undefined;
}
export interface EnableInsightRulesInput {
  RuleNames: string[] | undefined;
}
export interface EnableInsightRulesOutput {
  Failures?: PartialFailure[];
}
export declare class LimitExceededException extends __BaseException {
  readonly name: "LimitExceededException";
  readonly $fault: "client";
  Message?: string;
  constructor(
    opts: __ExceptionOptionType<LimitExceededException, __BaseException>
  );
}
export interface GetDashboardInput {
  DashboardName: string | undefined;
}
export interface GetDashboardOutput {
  DashboardArn?: string;
  DashboardBody?: string;
  DashboardName?: string;
}
export interface GetInsightRuleReportInput {
  RuleName: string | undefined;
  StartTime: Date | undefined;
  EndTime: Date | undefined;
  Period: number | undefined;
  MaxContributorCount?: number;
  Metrics?: string[];
  OrderBy?: string;
}
export interface InsightRuleContributorDatapoint {
  Timestamp: Date | undefined;
  ApproximateValue: number | undefined;
}
export interface InsightRuleContributor {
  Keys: string[] | undefined;
  ApproximateAggregateValue: number | undefined;
  Datapoints: InsightRuleContributorDatapoint[] | undefined;
}
export interface InsightRuleMetricDatapoint {
  Timestamp: Date | undefined;
  UniqueContributors?: number;
  MaxContributorValue?: number;
  SampleCount?: number;
  Average?: number;
  Sum?: number;
  Minimum?: number;
  Maximum?: number;
}
export interface GetInsightRuleReportOutput {
  KeyLabels?: string[];
  AggregationStatistic?: string;
  AggregateValue?: number;
  ApproximateUniqueCount?: number;
  Contributors?: InsightRuleContributor[];
  MetricDatapoints?: InsightRuleMetricDatapoint[];
}
export interface LabelOptions {
  Timezone?: string;
}
export interface GetMetricDataInput {
  MetricDataQueries: MetricDataQuery[] | undefined;
  StartTime: Date | undefined;
  EndTime: Date | undefined;
  NextToken?: string;
  ScanBy?: ScanBy;
  MaxDatapoints?: number;
  LabelOptions?: LabelOptions;
}
export interface MessageData {
  Code?: string;
  Value?: string;
}
export declare const StatusCode: {
  readonly COMPLETE: "Complete";
  readonly FORBIDDEN: "Forbidden";
  readonly INTERNAL_ERROR: "InternalError";
  readonly PARTIAL_DATA: "PartialData";
};
export type StatusCode = (typeof StatusCode)[keyof typeof StatusCode];
export interface MetricDataResult {
  Id?: string;
  Label?: string;
  Timestamps?: Date[];
  Values?: number[];
  StatusCode?: StatusCode;
  Messages?: MessageData[];
}
export interface GetMetricDataOutput {
  MetricDataResults?: MetricDataResult[];
  NextToken?: string;
  Messages?: MessageData[];
}
export interface GetMetricStatisticsInput {
  Namespace: string | undefined;
  MetricName: string | undefined;
  Dimensions?: Dimension[];
  StartTime: Date | undefined;
  EndTime: Date | undefined;
  Period: number | undefined;
  Statistics?: Statistic[];
  ExtendedStatistics?: string[];
  Unit?: StandardUnit;
}
export interface GetMetricStatisticsOutput {
  Label?: string;
  Datapoints?: Datapoint[];
}
export interface GetMetricStreamInput {
  Name: string | undefined;
}
export interface MetricStreamFilter {
  Namespace?: string;
  MetricNames?: string[];
}
export declare const MetricStreamOutputFormat: {
  readonly JSON: "json";
  readonly OPEN_TELEMETRY_0_7: "opentelemetry0.7";
  readonly OPEN_TELEMETRY_1_0: "opentelemetry1.0";
};
export type MetricStreamOutputFormat =
  (typeof MetricStreamOutputFormat)[keyof typeof MetricStreamOutputFormat];
export interface MetricStreamStatisticsMetric {
  Namespace: string | undefined;
  MetricName: string | undefined;
}
export interface MetricStreamStatisticsConfiguration {
  IncludeMetrics: MetricStreamStatisticsMetric[] | undefined;
  AdditionalStatistics: string[] | undefined;
}
export interface GetMetricStreamOutput {
  Arn?: string;
  Name?: string;
  IncludeFilters?: MetricStreamFilter[];
  ExcludeFilters?: MetricStreamFilter[];
  FirehoseArn?: string;
  RoleArn?: string;
  State?: string;
  CreationDate?: Date;
  LastUpdateDate?: Date;
  OutputFormat?: MetricStreamOutputFormat;
  StatisticsConfigurations?: MetricStreamStatisticsConfiguration[];
  IncludeLinkedAccountsMetrics?: boolean;
}
export interface GetMetricWidgetImageInput {
  MetricWidget: string | undefined;
  OutputFormat?: string;
}
export interface GetMetricWidgetImageOutput {
  MetricWidgetImage?: Uint8Array;
}
export interface ListDashboardsInput {
  DashboardNamePrefix?: string;
  NextToken?: string;
}
export interface ListDashboardsOutput {
  DashboardEntries?: DashboardEntry[];
  NextToken?: string;
}
export interface ListManagedInsightRulesInput {
  ResourceARN: string | undefined;
  NextToken?: string;
  MaxResults?: number;
}
export interface ManagedRuleState {
  RuleName: string | undefined;
  State: string | undefined;
}
export interface ManagedRuleDescription {
  TemplateName?: string;
  ResourceARN?: string;
  RuleState?: ManagedRuleState;
}
export interface ListManagedInsightRulesOutput {
  ManagedRules?: ManagedRuleDescription[];
  NextToken?: string;
}
export declare const RecentlyActive: {
  readonly PT3H: "PT3H";
};
export type RecentlyActive =
  (typeof RecentlyActive)[keyof typeof RecentlyActive];
export interface ListMetricsInput {
  Namespace?: string;
  MetricName?: string;
  Dimensions?: DimensionFilter[];
  NextToken?: string;
  RecentlyActive?: RecentlyActive;
  IncludeLinkedAccounts?: boolean;
  OwningAccount?: string;
}
export interface ListMetricsOutput {
  Metrics?: Metric[];
  NextToken?: string;
  OwningAccounts?: string[];
}
export interface ListMetricStreamsInput {
  NextToken?: string;
  MaxResults?: number;
}
export interface MetricStreamEntry {
  Arn?: string;
  CreationDate?: Date;
  LastUpdateDate?: Date;
  Name?: string;
  FirehoseArn?: string;
  State?: string;
  OutputFormat?: MetricStreamOutputFormat;
}
export interface ListMetricStreamsOutput {
  NextToken?: string;
  Entries?: MetricStreamEntry[];
}
export interface ListTagsForResourceInput {
  ResourceARN: string | undefined;
}
export interface Tag {
  Key: string | undefined;
  Value: string | undefined;
}
export interface ListTagsForResourceOutput {
  Tags?: Tag[];
}
export interface PutAnomalyDetectorInput {
  Namespace?: string;
  MetricName?: string;
  Dimensions?: Dimension[];
  Stat?: string;
  Configuration?: AnomalyDetectorConfiguration;
  SingleMetricAnomalyDetector?: SingleMetricAnomalyDetector;
  MetricMathAnomalyDetector?: MetricMathAnomalyDetector;
}
export interface PutAnomalyDetectorOutput {}
export declare class LimitExceededFault extends __BaseException {
  readonly name: "LimitExceededFault";
  readonly $fault: "client";
  constructor(opts: __ExceptionOptionType<LimitExceededFault, __BaseException>);
}
export interface PutCompositeAlarmInput {
  ActionsEnabled?: boolean;
  AlarmActions?: string[];
  AlarmDescription?: string;
  AlarmName: string | undefined;
  AlarmRule: string | undefined;
  InsufficientDataActions?: string[];
  OKActions?: string[];
  Tags?: Tag[];
  ActionsSuppressor?: string;
  ActionsSuppressorWaitPeriod?: number;
  ActionsSuppressorExtensionPeriod?: number;
}
export interface PutDashboardInput {
  DashboardName: string | undefined;
  DashboardBody: string | undefined;
}
export interface PutDashboardOutput {
  DashboardValidationMessages?: DashboardValidationMessage[];
}
export interface PutInsightRuleInput {
  RuleName: string | undefined;
  RuleState?: string;
  RuleDefinition: string | undefined;
  Tags?: Tag[];
}
export interface PutInsightRuleOutput {}
export interface ManagedRule {
  TemplateName: string | undefined;
  ResourceARN: string | undefined;
  Tags?: Tag[];
}
export interface PutManagedInsightRulesInput {
  ManagedRules: ManagedRule[] | undefined;
}
export interface PutManagedInsightRulesOutput {
  Failures?: PartialFailure[];
}
export interface PutMetricAlarmInput {
  AlarmName: string | undefined;
  AlarmDescription?: string;
  ActionsEnabled?: boolean;
  OKActions?: string[];
  AlarmActions?: string[];
  InsufficientDataActions?: string[];
  MetricName?: string;
  Namespace?: string;
  Statistic?: Statistic;
  ExtendedStatistic?: string;
  Dimensions?: Dimension[];
  Period?: number;
  Unit?: StandardUnit;
  EvaluationPeriods: number | undefined;
  DatapointsToAlarm?: number;
  Threshold?: number;
  ComparisonOperator: ComparisonOperator | undefined;
  TreatMissingData?: string;
  EvaluateLowSampleCountPercentile?: string;
  Metrics?: MetricDataQuery[];
  Tags?: Tag[];
  ThresholdMetricId?: string;
}
export interface StatisticSet {
  SampleCount: number | undefined;
  Sum: number | undefined;
  Minimum: number | undefined;
  Maximum: number | undefined;
}
export interface MetricDatum {
  MetricName: string | undefined;
  Dimensions?: Dimension[];
  Timestamp?: Date;
  Value?: number;
  StatisticValues?: StatisticSet;
  Values?: number[];
  Counts?: number[];
  Unit?: StandardUnit;
  StorageResolution?: number;
}
export interface PutMetricDataInput {
  Namespace: string | undefined;
  MetricData: MetricDatum[] | undefined;
}
export interface PutMetricStreamInput {
  Name: string | undefined;
  IncludeFilters?: MetricStreamFilter[];
  ExcludeFilters?: MetricStreamFilter[];
  FirehoseArn: string | undefined;
  RoleArn: string | undefined;
  OutputFormat: MetricStreamOutputFormat | undefined;
  Tags?: Tag[];
  StatisticsConfigurations?: MetricStreamStatisticsConfiguration[];
  IncludeLinkedAccountsMetrics?: boolean;
}
export interface PutMetricStreamOutput {
  Arn?: string;
}
export declare class InvalidFormatFault extends __BaseException {
  readonly name: "InvalidFormatFault";
  readonly $fault: "client";
  constructor(opts: __ExceptionOptionType<InvalidFormatFault, __BaseException>);
}
export interface SetAlarmStateInput {
  AlarmName: string | undefined;
  StateValue: StateValue | undefined;
  StateReason: string | undefined;
  StateReasonData?: string;
}
export interface StartMetricStreamsInput {
  Names: string[] | undefined;
}
export interface StartMetricStreamsOutput {}
export interface StopMetricStreamsInput {
  Names: string[] | undefined;
}
export interface StopMetricStreamsOutput {}
export interface TagResourceInput {
  ResourceARN: string | undefined;
  Tags: Tag[] | undefined;
}
export interface TagResourceOutput {}
export interface UntagResourceInput {
  ResourceARN: string | undefined;
  TagKeys: string[] | undefined;
}
export interface UntagResourceOutput {}
