import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type ServiceLevelObjectiveArn = string;
export type ServiceLevelObjectiveName = string;
export type Attainment = number;
export type TotalBudgetSeconds = number;
export type BudgetSecondsRemaining = number;
export type TotalBudgetRequests = number;
export type BudgetRequestsRemaining = number;
export type KeyAttributeName = string;
export type KeyAttributeValue = string;
export type OperationName = string;
export type MetricId = string;
export type Namespace = string;
export type MetricName = string;
export type DimensionName = string;
export type DimensionValue = string;
export type Period = number;
export type Stat = string;
export type MetricExpression = string;
export type MetricLabel = string;
export type ReturnData = boolean;
export type AccountId = string;
export type ServiceLevelIndicatorMetricThreshold = number;
export type RollingIntervalDuration = number;
export type CalendarIntervalDuration = number;
export type AttainmentGoal = number;
export type WarningThreshold = number;
export type ServiceLevelObjectiveBudgetReportErrorCode = string;
export type ServiceLevelObjectiveBudgetReportErrorMessage = string;
export type ValidationExceptionMessage = string;
export type ExclusionDuration = number;
export type Expression = string;
export type ExclusionReason = string;
export type ServiceLevelObjectiveId = string;
export type ExclusionWindowErrorCode = string;
export type ExclusionWindowErrorMessage = string;
export type ResourceType = string;
export type ResourceId = string;
export type FaultDescription = string;
export type ServiceErrorMessage = string;
export type GroupName = string;
export type GroupValue = string;
export type GroupSource = string;
export type GroupIdentifier = string;
export type MetricType = string;
export type AwsAccountId = string;
export type NextToken = string;
export type ListAuditFindingMaxResults = number;
export type ListEntityEventsMaxResults = number;
export type GroupingString = string;
export type ListServiceDependenciesMaxResults = number;
export type ListServiceDependentsMaxResults = number;
export type ListServiceLevelObjectiveExclusionWindowsMaxResults = number;
export type ListServiceOperationMaxResults = number;
export type ListServicesMaxResults = number;
export type ListServiceStatesMaxResults = number;
export type AttributeFilterName = string;
export type AttributeFilterValue = string;
export type AmazonResourceName = string;
export type TagKey = string;
export type TagValue = string;
export type ServiceLevelObjectiveDescription = string;
export type ServiceLevelIndicatorStatistic = string;
export type SLIPeriodSeconds = number;
export type BurnRateLookBackWindowMinutes = number;
export type ListServiceLevelObjectivesMaxResults = number;
export type ServiceLevelObjectiveIds = string[];
export declare const ServiceLevelObjectiveIds: S.$Array<S.String>;
export interface BatchGetServiceLevelObjectiveBudgetReportInput {
    Timestamp: Date;
    SloIds: string[];
}
export declare const BatchGetServiceLevelObjectiveBudgetReportInput: S.Schema<BatchGetServiceLevelObjectiveBudgetReportInput>;
export type EvaluationType = "PeriodBased" | "RequestBased" | (string & {});
export declare const EvaluationType: S.String;
export type ServiceLevelObjectiveBudgetStatus = "OK" | "WARNING" | "BREACHED" | "INSUFFICIENT_DATA" | (string & {});
export declare const ServiceLevelObjectiveBudgetStatus: S.String;
export type Attributes = {
    [key: string]: string | undefined;
};
export declare const Attributes: S.$Record<S.String, S.optional<S.String>>;
export type ServiceLevelIndicatorMetricType = "LATENCY" | "AVAILABILITY" | (string & {});
export declare const ServiceLevelIndicatorMetricType: S.String;
export interface Dimension {
    Name: string;
    Value: string;
}
export declare const Dimension: S.Schema<Dimension>;
export type Dimensions = Dimension[];
export declare const Dimensions: S.$Array<S.Schema<Dimension>>;
export interface Metric {
    Namespace?: string;
    MetricName?: string;
    Dimensions?: Dimension[];
}
export declare const Metric: S.Schema<Metric>;
export type StandardUnit = "Microseconds" | "Milliseconds" | "Seconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second" | "None" | (string & {});
export declare const StandardUnit: S.String;
export interface MetricStat {
    Metric: Metric;
    Period: number;
    Stat: string;
    Unit?: StandardUnit;
}
export declare const MetricStat: S.Schema<MetricStat>;
export interface MetricDataQuery {
    Id: string;
    MetricStat?: MetricStat;
    Expression?: string;
    Label?: string;
    ReturnData?: boolean;
    Period?: number;
    AccountId?: string;
}
export declare const MetricDataQuery: S.Schema<MetricDataQuery>;
export type MetricDataQueries = MetricDataQuery[];
export declare const MetricDataQueries: S.$Array<S.Schema<MetricDataQuery>>;
export interface DependencyConfig {
    DependencyKeyAttributes: {
        [key: string]: string | undefined;
    };
    DependencyOperationName: string;
}
export declare const DependencyConfig: S.Schema<DependencyConfig>;
export interface MetricSource {
    MetricSourceKeyAttributes: {
        [key: string]: string | undefined;
    };
    MetricSourceAttributes?: {
        [key: string]: string | undefined;
    };
}
export declare const MetricSource: S.Schema<MetricSource>;
export interface ServiceLevelIndicatorMetric {
    KeyAttributes?: {
        [key: string]: string | undefined;
    };
    OperationName?: string;
    MetricType?: ServiceLevelIndicatorMetricType;
    MetricDataQueries: MetricDataQuery[];
    DependencyConfig?: DependencyConfig;
    MetricSource?: MetricSource;
}
export declare const ServiceLevelIndicatorMetric: S.Schema<ServiceLevelIndicatorMetric>;
export type ServiceLevelIndicatorComparisonOperator = "GreaterThanOrEqualTo" | "GreaterThan" | "LessThan" | "LessThanOrEqualTo" | (string & {});
export declare const ServiceLevelIndicatorComparisonOperator: S.String;
export interface ServiceLevelIndicator {
    SliMetric: ServiceLevelIndicatorMetric;
    MetricThreshold: number;
    ComparisonOperator: ServiceLevelIndicatorComparisonOperator;
}
export declare const ServiceLevelIndicator: S.Schema<ServiceLevelIndicator>;
export type MonitoredRequestCountMetricDataQueries = {
    GoodCountMetric: MetricDataQuery[];
    BadCountMetric?: never;
} | {
    GoodCountMetric?: never;
    BadCountMetric: MetricDataQuery[];
};
export declare const MonitoredRequestCountMetricDataQueries: S.Union<readonly [S.Struct<{
    readonly GoodCountMetric: S.$Array<S.Schema<MetricDataQuery>>;
}>, S.Struct<{
    readonly BadCountMetric: S.$Array<S.Schema<MetricDataQuery>>;
}>]>;
export interface RequestBasedServiceLevelIndicatorMetric {
    KeyAttributes?: {
        [key: string]: string | undefined;
    };
    OperationName?: string;
    MetricType?: ServiceLevelIndicatorMetricType;
    TotalRequestCountMetric: MetricDataQuery[];
    MonitoredRequestCountMetric: MonitoredRequestCountMetricDataQueries;
    DependencyConfig?: DependencyConfig;
    MetricSource?: MetricSource;
}
export declare const RequestBasedServiceLevelIndicatorMetric: S.Schema<RequestBasedServiceLevelIndicatorMetric>;
export interface RequestBasedServiceLevelIndicator {
    RequestBasedSliMetric: RequestBasedServiceLevelIndicatorMetric;
    MetricThreshold?: number;
    ComparisonOperator?: ServiceLevelIndicatorComparisonOperator;
}
export declare const RequestBasedServiceLevelIndicator: S.Schema<RequestBasedServiceLevelIndicator>;
export type DurationUnit = "MINUTE" | "HOUR" | "DAY" | "MONTH" | (string & {});
export declare const DurationUnit: S.String;
export interface RollingInterval {
    DurationUnit: DurationUnit;
    Duration: number;
}
export declare const RollingInterval: S.Schema<RollingInterval>;
export interface CalendarInterval {
    StartTime: Date;
    DurationUnit: DurationUnit;
    Duration: number;
}
export declare const CalendarInterval: S.Schema<CalendarInterval>;
export type Interval = {
    RollingInterval: RollingInterval;
    CalendarInterval?: never;
} | {
    RollingInterval?: never;
    CalendarInterval: CalendarInterval;
};
export declare const Interval: S.Union<readonly [S.Struct<{
    readonly RollingInterval: S.Schema<RollingInterval>;
}>, S.Struct<{
    readonly CalendarInterval: S.Schema<CalendarInterval>;
}>]>;
export interface Goal {
    Interval?: Interval;
    AttainmentGoal?: number;
    WarningThreshold?: number;
}
export declare const Goal: S.Schema<Goal>;
export interface ServiceLevelObjectiveBudgetReport {
    Arn: string;
    Name: string;
    EvaluationType?: EvaluationType;
    BudgetStatus: ServiceLevelObjectiveBudgetStatus;
    Attainment?: number;
    TotalBudgetSeconds?: number;
    BudgetSecondsRemaining?: number;
    TotalBudgetRequests?: number;
    BudgetRequestsRemaining?: number;
    Sli?: ServiceLevelIndicator;
    RequestBasedSli?: RequestBasedServiceLevelIndicator;
    Goal?: Goal;
}
export declare const ServiceLevelObjectiveBudgetReport: S.Schema<ServiceLevelObjectiveBudgetReport>;
export type ServiceLevelObjectiveBudgetReports = ServiceLevelObjectiveBudgetReport[];
export declare const ServiceLevelObjectiveBudgetReports: S.$Array<S.Schema<ServiceLevelObjectiveBudgetReport>>;
export interface ServiceLevelObjectiveBudgetReportError {
    Name: string;
    Arn: string;
    ErrorCode: string;
    ErrorMessage: string;
}
export declare const ServiceLevelObjectiveBudgetReportError: S.Schema<ServiceLevelObjectiveBudgetReportError>;
export type ServiceLevelObjectiveBudgetReportErrors = ServiceLevelObjectiveBudgetReportError[];
export declare const ServiceLevelObjectiveBudgetReportErrors: S.$Array<S.Schema<ServiceLevelObjectiveBudgetReportError>>;
export interface BatchGetServiceLevelObjectiveBudgetReportOutput {
    Timestamp: Date;
    Reports: ServiceLevelObjectiveBudgetReport[];
    Errors: ServiceLevelObjectiveBudgetReportError[];
}
export declare const BatchGetServiceLevelObjectiveBudgetReportOutput: S.Schema<BatchGetServiceLevelObjectiveBudgetReportOutput>;
export interface Window {
    DurationUnit: DurationUnit;
    Duration: number;
}
export declare const Window: S.Schema<Window>;
export interface RecurrenceRule {
    Expression: string;
}
export declare const RecurrenceRule: S.Schema<RecurrenceRule>;
export interface ExclusionWindow {
    Window: Window;
    StartTime?: Date;
    RecurrenceRule?: RecurrenceRule;
    Reason?: string;
}
export declare const ExclusionWindow: S.Schema<ExclusionWindow>;
export type ExclusionWindows = ExclusionWindow[];
export declare const ExclusionWindows: S.$Array<S.Schema<ExclusionWindow>>;
export interface BatchUpdateExclusionWindowsInput {
    SloIds: string[];
    AddExclusionWindows?: ExclusionWindow[];
    RemoveExclusionWindows?: ExclusionWindow[];
}
export declare const BatchUpdateExclusionWindowsInput: S.Schema<BatchUpdateExclusionWindowsInput>;
export interface BatchUpdateExclusionWindowsError_ {
    SloId: string;
    ErrorCode: string;
    ErrorMessage: string;
}
export declare const BatchUpdateExclusionWindowsError_: S.Schema<BatchUpdateExclusionWindowsError_>;
export type BatchUpdateExclusionWindowsErrors = BatchUpdateExclusionWindowsError_[];
export declare const BatchUpdateExclusionWindowsErrors: S.$Array<S.Schema<BatchUpdateExclusionWindowsError_>>;
export interface BatchUpdateExclusionWindowsOutput {
    SloIds: string[];
    Errors: BatchUpdateExclusionWindowsError_[];
}
export declare const BatchUpdateExclusionWindowsOutput: S.Schema<BatchUpdateExclusionWindowsOutput>;
export interface DeleteGroupingConfigurationRequest {
}
export declare const DeleteGroupingConfigurationRequest: S.Schema<DeleteGroupingConfigurationRequest>;
export interface DeleteGroupingConfigurationOutput {
}
export declare const DeleteGroupingConfigurationOutput: S.Schema<DeleteGroupingConfigurationOutput>;
export interface GetServiceInput {
    StartTime: Date;
    EndTime: Date;
    KeyAttributes: {
        [key: string]: string | undefined;
    };
}
export declare const GetServiceInput: S.Schema<GetServiceInput>;
export type AttributeMap = {
    [key: string]: string | undefined;
};
export declare const AttributeMap: S.$Record<S.String, S.optional<S.String>>;
export type AttributeMaps = {
    [key: string]: string | undefined;
}[];
export declare const AttributeMaps: S.$Array<S.$Record<S.String, S.optional<S.String>>>;
export interface ServiceGroup {
    GroupName: string;
    GroupValue: string;
    GroupSource: string;
    GroupIdentifier: string;
}
export declare const ServiceGroup: S.Schema<ServiceGroup>;
export type ServiceGroups = ServiceGroup[];
export declare const ServiceGroups: S.$Array<S.Schema<ServiceGroup>>;
export interface MetricReference {
    Namespace: string;
    MetricType: string;
    Dimensions?: Dimension[];
    MetricName: string;
    AccountId?: string;
}
export declare const MetricReference: S.Schema<MetricReference>;
export type MetricReferences = MetricReference[];
export declare const MetricReferences: S.$Array<S.Schema<MetricReference>>;
export type LogGroupReferences = {
    [key: string]: string | undefined;
}[];
export declare const LogGroupReferences: S.$Array<S.$Record<S.String, S.optional<S.String>>>;
export interface Service {
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    AttributeMaps?: {
        [key: string]: string | undefined;
    }[];
    ServiceGroups?: ServiceGroup[];
    MetricReferences: MetricReference[];
    LogGroupReferences?: {
        [key: string]: string | undefined;
    }[];
}
export declare const Service: S.Schema<Service>;
export interface GetServiceOutput {
    Service: Service;
    StartTime: Date;
    EndTime: Date;
    LogGroupReferences?: {
        [key: string]: string | undefined;
    }[];
}
export declare const GetServiceOutput: S.Schema<GetServiceOutput>;
export type Auditors = string[];
export declare const Auditors: S.$Array<S.String>;
export interface ServiceEntity {
    Type?: string;
    Name?: string;
    Environment?: string;
    AwsAccountId?: string;
}
export declare const ServiceEntity: S.Schema<ServiceEntity>;
export interface ServiceLevelObjectiveEntity {
    SloName?: string;
    SloArn?: string;
}
export declare const ServiceLevelObjectiveEntity: S.Schema<ServiceLevelObjectiveEntity>;
export interface ServiceOperationEntity {
    Service?: ServiceEntity;
    Operation?: string;
    MetricType?: string;
}
export declare const ServiceOperationEntity: S.Schema<ServiceOperationEntity>;
export interface CanaryEntity {
    CanaryName: string;
}
export declare const CanaryEntity: S.Schema<CanaryEntity>;
export type AuditTargetEntity = {
    Service: ServiceEntity;
    Slo?: never;
    ServiceOperation?: never;
    Canary?: never;
} | {
    Service?: never;
    Slo: ServiceLevelObjectiveEntity;
    ServiceOperation?: never;
    Canary?: never;
} | {
    Service?: never;
    Slo?: never;
    ServiceOperation: ServiceOperationEntity;
    Canary?: never;
} | {
    Service?: never;
    Slo?: never;
    ServiceOperation?: never;
    Canary: CanaryEntity;
};
export declare const AuditTargetEntity: S.Union<readonly [S.Struct<{
    readonly Service: S.Schema<ServiceEntity>;
}>, S.Struct<{
    readonly Slo: S.Schema<ServiceLevelObjectiveEntity>;
}>, S.Struct<{
    readonly ServiceOperation: S.Schema<ServiceOperationEntity>;
}>, S.Struct<{
    readonly Canary: S.Schema<CanaryEntity>;
}>]>;
export interface AuditTarget {
    Type: string;
    Data: AuditTargetEntity;
}
export declare const AuditTarget: S.Schema<AuditTarget>;
export type AuditTargets = AuditTarget[];
export declare const AuditTargets: S.$Array<S.Schema<AuditTarget>>;
export type DetailLevel = "BRIEF" | "DETAILED" | (string & {});
export declare const DetailLevel: S.String;
export interface ListAuditFindingsInput {
    StartTime: Date;
    EndTime: Date;
    Auditors?: string[];
    AuditTargets: AuditTarget[];
    DetailLevel?: DetailLevel;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListAuditFindingsInput: S.Schema<ListAuditFindingsInput>;
export type DataMap = {
    [key: string]: string | undefined;
};
export declare const DataMap: S.$Record<S.String, S.optional<S.String>>;
export type Severity = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "NONE" | (string & {});
export declare const Severity: S.String;
export interface AuditorResult {
    Auditor?: string;
    Description?: string;
    Data?: {
        [key: string]: string | undefined;
    };
    Severity?: Severity;
}
export declare const AuditorResult: S.Schema<AuditorResult>;
export type AuditorResults = AuditorResult[];
export declare const AuditorResults: S.$Array<S.Schema<AuditorResult>>;
export interface MetricGraph {
    MetricDataQueries?: MetricDataQuery[];
    StartTime?: Date;
    EndTime?: Date;
}
export declare const MetricGraph: S.Schema<MetricGraph>;
export interface Node {
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    Name: string;
    NodeId: string;
    Operation?: string;
    Type?: string;
    Duration?: number;
    Status?: string;
}
export declare const Node: S.Schema<Node>;
export type Nodes = Node[];
export declare const Nodes: S.$Array<S.Schema<Node>>;
export type ConnectionType = "INDIRECT" | "DIRECT" | (string & {});
export declare const ConnectionType: S.String;
export interface Edge {
    SourceNodeId?: string;
    DestinationNodeId?: string;
    Duration?: number;
    ConnectionType?: ConnectionType;
}
export declare const Edge: S.Schema<Edge>;
export type Edges = Edge[];
export declare const Edges: S.$Array<S.Schema<Edge>>;
export interface DependencyGraph {
    Nodes?: Node[];
    Edges?: Edge[];
}
export declare const DependencyGraph: S.Schema<DependencyGraph>;
export interface AuditFinding {
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    AuditorResults?: AuditorResult[];
    Operation?: string;
    MetricGraph?: MetricGraph;
    DependencyGraph?: DependencyGraph;
    Type?: string;
}
export declare const AuditFinding: S.Schema<AuditFinding>;
export type AuditFindings = AuditFinding[];
export declare const AuditFindings: S.$Array<S.Schema<AuditFinding>>;
export interface ListAuditFindingsOutput {
    StartTime?: Date;
    EndTime?: Date;
    AuditFindings: AuditFinding[];
    NextToken?: string;
}
export declare const ListAuditFindingsOutput: S.Schema<ListAuditFindingsOutput>;
export interface ListEntityEventsInput {
    Entity: {
        [key: string]: string | undefined;
    };
    StartTime: Date;
    EndTime: Date;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListEntityEventsInput: S.Schema<ListEntityEventsInput>;
export type ChangeEventType = "DEPLOYMENT" | "CONFIGURATION" | (string & {});
export declare const ChangeEventType: S.String;
export interface ChangeEvent {
    Timestamp: Date;
    AccountId: string;
    Region: string;
    Entity: {
        [key: string]: string | undefined;
    };
    ChangeEventType: ChangeEventType;
    EventId: string;
    UserName?: string;
    EventName?: string;
}
export declare const ChangeEvent: S.Schema<ChangeEvent>;
export type ChangeEvents = ChangeEvent[];
export declare const ChangeEvents: S.$Array<S.Schema<ChangeEvent>>;
export interface ListEntityEventsOutput {
    StartTime: Date;
    EndTime: Date;
    ChangeEvents: ChangeEvent[];
    NextToken?: string;
}
export declare const ListEntityEventsOutput: S.Schema<ListEntityEventsOutput>;
export interface ListGroupingAttributeDefinitionsInput {
    NextToken?: string;
    AwsAccountId?: string;
    IncludeLinkedAccounts?: boolean;
}
export declare const ListGroupingAttributeDefinitionsInput: S.Schema<ListGroupingAttributeDefinitionsInput>;
export type GroupingSourceKeyStringList = string[];
export declare const GroupingSourceKeyStringList: S.$Array<S.String>;
export interface GroupingAttributeDefinition {
    GroupingName: string;
    GroupingSourceKeys?: string[];
    DefaultGroupingValue?: string;
}
export declare const GroupingAttributeDefinition: S.Schema<GroupingAttributeDefinition>;
export type GroupingAttributeDefinitions = GroupingAttributeDefinition[];
export declare const GroupingAttributeDefinitions: S.$Array<S.Schema<GroupingAttributeDefinition>>;
export interface ListGroupingAttributeDefinitionsOutput {
    GroupingAttributeDefinitions: GroupingAttributeDefinition[];
    UpdatedAt?: Date;
    NextToken?: string;
}
export declare const ListGroupingAttributeDefinitionsOutput: S.Schema<ListGroupingAttributeDefinitionsOutput>;
export interface ListServiceDependenciesInput {
    StartTime: Date;
    EndTime: Date;
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListServiceDependenciesInput: S.Schema<ListServiceDependenciesInput>;
export interface ServiceDependency {
    OperationName: string;
    DependencyKeyAttributes: {
        [key: string]: string | undefined;
    };
    DependencyOperationName: string;
    MetricReferences: MetricReference[];
}
export declare const ServiceDependency: S.Schema<ServiceDependency>;
export type ServiceDependencies = ServiceDependency[];
export declare const ServiceDependencies: S.$Array<S.Schema<ServiceDependency>>;
export interface ListServiceDependenciesOutput {
    StartTime: Date;
    EndTime: Date;
    ServiceDependencies: ServiceDependency[];
    NextToken?: string;
}
export declare const ListServiceDependenciesOutput: S.Schema<ListServiceDependenciesOutput>;
export interface ListServiceDependentsInput {
    StartTime: Date;
    EndTime: Date;
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListServiceDependentsInput: S.Schema<ListServiceDependentsInput>;
export interface ServiceDependent {
    OperationName?: string;
    DependentKeyAttributes: {
        [key: string]: string | undefined;
    };
    DependentOperationName?: string;
    MetricReferences: MetricReference[];
}
export declare const ServiceDependent: S.Schema<ServiceDependent>;
export type ServiceDependents = ServiceDependent[];
export declare const ServiceDependents: S.$Array<S.Schema<ServiceDependent>>;
export interface ListServiceDependentsOutput {
    StartTime: Date;
    EndTime: Date;
    ServiceDependents: ServiceDependent[];
    NextToken?: string;
}
export declare const ListServiceDependentsOutput: S.Schema<ListServiceDependentsOutput>;
export interface ListServiceLevelObjectiveExclusionWindowsInput {
    Id: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListServiceLevelObjectiveExclusionWindowsInput: S.Schema<ListServiceLevelObjectiveExclusionWindowsInput>;
export interface ListServiceLevelObjectiveExclusionWindowsOutput {
    ExclusionWindows: ExclusionWindow[];
    NextToken?: string;
}
export declare const ListServiceLevelObjectiveExclusionWindowsOutput: S.Schema<ListServiceLevelObjectiveExclusionWindowsOutput>;
export interface ListServiceOperationsInput {
    StartTime: Date;
    EndTime: Date;
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListServiceOperationsInput: S.Schema<ListServiceOperationsInput>;
export interface ServiceOperation {
    Name: string;
    MetricReferences: MetricReference[];
}
export declare const ServiceOperation: S.Schema<ServiceOperation>;
export type ServiceOperations = ServiceOperation[];
export declare const ServiceOperations: S.$Array<S.Schema<ServiceOperation>>;
export interface ListServiceOperationsOutput {
    StartTime: Date;
    EndTime: Date;
    ServiceOperations: ServiceOperation[];
    NextToken?: string;
}
export declare const ListServiceOperationsOutput: S.Schema<ListServiceOperationsOutput>;
export interface ListServicesInput {
    StartTime: Date;
    EndTime: Date;
    MaxResults?: number;
    NextToken?: string;
    IncludeLinkedAccounts?: boolean;
    AwsAccountId?: string;
}
export declare const ListServicesInput: S.Schema<ListServicesInput>;
export interface ServiceSummary {
    KeyAttributes: {
        [key: string]: string | undefined;
    };
    AttributeMaps?: {
        [key: string]: string | undefined;
    }[];
    MetricReferences: MetricReference[];
    ServiceGroups?: ServiceGroup[];
}
export declare const ServiceSummary: S.Schema<ServiceSummary>;
export type ServiceSummaries = ServiceSummary[];
export declare const ServiceSummaries: S.$Array<S.Schema<ServiceSummary>>;
export interface ListServicesOutput {
    StartTime: Date;
    EndTime: Date;
    ServiceSummaries: ServiceSummary[];
    NextToken?: string;
}
export declare const ListServicesOutput: S.Schema<ListServicesOutput>;
export type AttributeFilterValues = string[];
export declare const AttributeFilterValues: S.$Array<S.String>;
export interface AttributeFilter {
    AttributeFilterName: string;
    AttributeFilterValues: string[];
}
export declare const AttributeFilter: S.Schema<AttributeFilter>;
export type AttributeFilters = AttributeFilter[];
export declare const AttributeFilters: S.$Array<S.Schema<AttributeFilter>>;
export interface ListServiceStatesInput {
    StartTime: Date;
    EndTime: Date;
    MaxResults?: number;
    NextToken?: string;
    IncludeLinkedAccounts?: boolean;
    AwsAccountId?: string;
    AttributeFilters?: AttributeFilter[];
}
export declare const ListServiceStatesInput: S.Schema<ListServiceStatesInput>;
export type LatestChangeEvents = ChangeEvent[];
export declare const LatestChangeEvents: S.$Array<S.Schema<ChangeEvent>>;
export interface ServiceState {
    AttributeFilters?: AttributeFilter[];
    Service: {
        [key: string]: string | undefined;
    };
    LatestChangeEvents: ChangeEvent[];
}
export declare const ServiceState: S.Schema<ServiceState>;
export type ServiceStates = ServiceState[];
export declare const ServiceStates: S.$Array<S.Schema<ServiceState>>;
export interface ListServiceStatesOutput {
    StartTime: Date;
    EndTime: Date;
    ServiceStates: ServiceState[];
    NextToken?: string;
}
export declare const ListServiceStatesOutput: S.Schema<ListServiceStatesOutput>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface Tag {
    Key: string;
    Value: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface ListTagsForResourceResponse {
    Tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface PutGroupingConfigurationInput {
    GroupingAttributeDefinitions: GroupingAttributeDefinition[];
}
export declare const PutGroupingConfigurationInput: S.Schema<PutGroupingConfigurationInput>;
export interface GroupingConfiguration {
    GroupingAttributeDefinitions: GroupingAttributeDefinition[];
    UpdatedAt: Date;
}
export declare const GroupingConfiguration: S.Schema<GroupingConfiguration>;
export interface PutGroupingConfigurationOutput {
    GroupingConfiguration: GroupingConfiguration;
}
export declare const PutGroupingConfigurationOutput: S.Schema<PutGroupingConfigurationOutput>;
export interface StartDiscoveryInput {
}
export declare const StartDiscoveryInput: S.Schema<StartDiscoveryInput>;
export interface StartDiscoveryOutput {
}
export declare const StartDiscoveryOutput: S.Schema<StartDiscoveryOutput>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface ServiceLevelIndicatorMetricConfig {
    KeyAttributes?: {
        [key: string]: string | undefined;
    };
    OperationName?: string;
    MetricType?: ServiceLevelIndicatorMetricType;
    MetricName?: string;
    Statistic?: string;
    PeriodSeconds?: number;
    MetricSource?: MetricSource;
    MetricDataQueries?: MetricDataQuery[];
    DependencyConfig?: DependencyConfig;
}
export declare const ServiceLevelIndicatorMetricConfig: S.Schema<ServiceLevelIndicatorMetricConfig>;
export interface ServiceLevelIndicatorConfig {
    SliMetricConfig: ServiceLevelIndicatorMetricConfig;
    MetricThreshold: number;
    ComparisonOperator: ServiceLevelIndicatorComparisonOperator;
}
export declare const ServiceLevelIndicatorConfig: S.Schema<ServiceLevelIndicatorConfig>;
export interface RequestBasedServiceLevelIndicatorMetricConfig {
    KeyAttributes?: {
        [key: string]: string | undefined;
    };
    OperationName?: string;
    MetricType?: ServiceLevelIndicatorMetricType;
    TotalRequestCountMetric?: MetricDataQuery[];
    MonitoredRequestCountMetric?: MonitoredRequestCountMetricDataQueries;
    DependencyConfig?: DependencyConfig;
    MetricSource?: MetricSource;
    MetricName?: string;
}
export declare const RequestBasedServiceLevelIndicatorMetricConfig: S.Schema<RequestBasedServiceLevelIndicatorMetricConfig>;
export interface RequestBasedServiceLevelIndicatorConfig {
    RequestBasedSliMetricConfig: RequestBasedServiceLevelIndicatorMetricConfig;
    MetricThreshold?: number;
    ComparisonOperator?: ServiceLevelIndicatorComparisonOperator;
}
export declare const RequestBasedServiceLevelIndicatorConfig: S.Schema<RequestBasedServiceLevelIndicatorConfig>;
export interface BurnRateConfiguration {
    LookBackWindowMinutes: number;
}
export declare const BurnRateConfiguration: S.Schema<BurnRateConfiguration>;
export type BurnRateConfigurations = BurnRateConfiguration[];
export declare const BurnRateConfigurations: S.$Array<S.Schema<BurnRateConfiguration>>;
export interface CreateServiceLevelObjectiveInput {
    Name: string;
    Description?: string;
    SliConfig?: ServiceLevelIndicatorConfig;
    RequestBasedSliConfig?: RequestBasedServiceLevelIndicatorConfig;
    Goal?: Goal;
    Tags?: Tag[];
    BurnRateConfigurations?: BurnRateConfiguration[];
}
export declare const CreateServiceLevelObjectiveInput: S.Schema<CreateServiceLevelObjectiveInput>;
export type MetricSourceType = "ServiceOperation" | "CloudWatchMetric" | "ServiceDependency" | "AppMonitor" | "Canary" | "Service" | (string & {});
export declare const MetricSourceType: S.String;
export interface ServiceLevelObjective {
    Arn: string;
    Name: string;
    Description?: string;
    CreatedTime: Date;
    LastUpdatedTime: Date;
    Sli?: ServiceLevelIndicator;
    RequestBasedSli?: RequestBasedServiceLevelIndicator;
    EvaluationType?: EvaluationType;
    Goal: Goal;
    BurnRateConfigurations?: BurnRateConfiguration[];
    MetricSourceType?: MetricSourceType;
}
export declare const ServiceLevelObjective: S.Schema<ServiceLevelObjective>;
export interface CreateServiceLevelObjectiveOutput {
    Slo: ServiceLevelObjective;
}
export declare const CreateServiceLevelObjectiveOutput: S.Schema<CreateServiceLevelObjectiveOutput>;
export interface GetServiceLevelObjectiveInput {
    Id: string;
}
export declare const GetServiceLevelObjectiveInput: S.Schema<GetServiceLevelObjectiveInput>;
export interface GetServiceLevelObjectiveOutput {
    Slo: ServiceLevelObjective;
}
export declare const GetServiceLevelObjectiveOutput: S.Schema<GetServiceLevelObjectiveOutput>;
export interface UpdateServiceLevelObjectiveInput {
    Id: string;
    Description?: string;
    SliConfig?: ServiceLevelIndicatorConfig;
    RequestBasedSliConfig?: RequestBasedServiceLevelIndicatorConfig;
    Goal?: Goal;
    BurnRateConfigurations?: BurnRateConfiguration[];
}
export declare const UpdateServiceLevelObjectiveInput: S.Schema<UpdateServiceLevelObjectiveInput>;
export interface UpdateServiceLevelObjectiveOutput {
    Slo: ServiceLevelObjective;
}
export declare const UpdateServiceLevelObjectiveOutput: S.Schema<UpdateServiceLevelObjectiveOutput>;
export interface DeleteServiceLevelObjectiveInput {
    Id: string;
}
export declare const DeleteServiceLevelObjectiveInput: S.Schema<DeleteServiceLevelObjectiveInput>;
export interface DeleteServiceLevelObjectiveOutput {
}
export declare const DeleteServiceLevelObjectiveOutput: S.Schema<DeleteServiceLevelObjectiveOutput>;
export type MetricSourceTypes = MetricSourceType[];
export declare const MetricSourceTypes: S.$Array<S.String>;
export interface ListServiceLevelObjectivesInput {
    KeyAttributes?: {
        [key: string]: string | undefined;
    };
    OperationName?: string;
    DependencyConfig?: DependencyConfig;
    MaxResults?: number;
    NextToken?: string;
    MetricSourceTypes?: MetricSourceType[];
    IncludeLinkedAccounts?: boolean;
    SloOwnerAwsAccountId?: string;
    MetricSource?: MetricSource;
}
export declare const ListServiceLevelObjectivesInput: S.Schema<ListServiceLevelObjectivesInput>;
export interface ServiceLevelObjectiveSummary {
    Arn: string;
    Name: string;
    KeyAttributes?: {
        [key: string]: string | undefined;
    };
    OperationName?: string;
    DependencyConfig?: DependencyConfig;
    CreatedTime?: Date;
    EvaluationType?: EvaluationType;
    MetricSourceType?: MetricSourceType;
    MetricSource?: MetricSource;
}
export declare const ServiceLevelObjectiveSummary: S.Schema<ServiceLevelObjectiveSummary>;
export type ServiceLevelObjectiveSummaries = ServiceLevelObjectiveSummary[];
export declare const ServiceLevelObjectiveSummaries: S.$Array<S.Schema<ServiceLevelObjectiveSummary>>;
export interface ListServiceLevelObjectivesOutput {
    SloSummaries?: ServiceLevelObjectiveSummary[];
    NextToken?: string;
}
export declare const ListServiceLevelObjectivesOutput: S.Schema<ListServiceLevelObjectivesOutput>;
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly ResourceType: S.String;
    readonly ResourceId: S.String;
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
export type BatchGetServiceLevelObjectiveBudgetReportError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to retrieve one or more *service level objective (SLO) budget reports*.
 *
 * An *error budget* is the amount of time or requests in an unhealthy state that your service can accumulate during an interval before your overall SLO budget health is breached and the SLO is considered to be unmet. For example, an SLO with a threshold of 99.95% and a monthly interval translates to an error budget of 21.9 minutes of downtime in a 30-day month.
 *
 * Budget reports include a health indicator, the attainment value, and remaining budget.
 *
 * For more information about SLO error budgets, see SLO concepts.
 */
export declare const batchGetServiceLevelObjectiveBudgetReport: API.OperationMethod<BatchGetServiceLevelObjectiveBudgetReportInput, BatchGetServiceLevelObjectiveBudgetReportOutput, BatchGetServiceLevelObjectiveBudgetReportError, Credentials | Region | HttpClient.HttpClient>;
export type BatchUpdateExclusionWindowsError = ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Add or remove time window exclusions for one or more Service Level Objectives (SLOs).
 */
export declare const batchUpdateExclusionWindows: API.OperationMethod<BatchUpdateExclusionWindowsInput, BatchUpdateExclusionWindowsOutput, BatchUpdateExclusionWindowsError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteGroupingConfigurationError = AccessDeniedException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes the grouping configuration for this account. This removes all custom grouping attribute definitions that were previously configured.
 */
export declare const deleteGroupingConfiguration: API.OperationMethod<DeleteGroupingConfigurationRequest, DeleteGroupingConfigurationOutput, DeleteGroupingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type GetServiceError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about a service discovered by Application Signals.
 */
export declare const getService: API.OperationMethod<GetServiceInput, GetServiceOutput, GetServiceError, Credentials | Region | HttpClient.HttpClient>;
export type ListAuditFindingsError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of audit findings that provide automated analysis of service behavior and root cause analysis. These findings help identify the most significant observations about your services, including performance issues, anomalies, and potential problems. The findings are generated using heuristic algorithms based on established troubleshooting patterns.
 */
export declare const listAuditFindings: API.OperationMethod<ListAuditFindingsInput, ListAuditFindingsOutput, ListAuditFindingsError, Credentials | Region | HttpClient.HttpClient>;
export type ListEntityEventsError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of change events for a specific entity, such as deployments, configuration changes, or other state-changing activities. This operation helps track the history of changes that may have affected service performance.
 */
export declare const listEntityEvents: API.OperationMethod<ListEntityEventsInput, ListEntityEventsOutput, ListEntityEventsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEntityEventsInput) => stream.Stream<ListEntityEventsOutput, ListEntityEventsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEntityEventsInput) => stream.Stream<ChangeEvent, ListEntityEventsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListGroupingAttributeDefinitionsError = AccessDeniedException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns the current grouping configuration for this account, including all custom grouping attribute definitions that have been configured. These definitions determine how services are logically grouped based on telemetry attributes, Amazon Web Services tags, or predefined mappings.
 */
export declare const listGroupingAttributeDefinitions: API.OperationMethod<ListGroupingAttributeDefinitionsInput, ListGroupingAttributeDefinitionsOutput, ListGroupingAttributeDefinitionsError, Credentials | Region | HttpClient.HttpClient>;
export type ListServiceDependenciesError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of service dependencies of the service that you specify. A dependency is an infrastructure component that an operation of this service connects with. Dependencies can include Amazon Web Services services, Amazon Web Services resources, and third-party services.
 */
export declare const listServiceDependencies: API.OperationMethod<ListServiceDependenciesInput, ListServiceDependenciesOutput, ListServiceDependenciesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceDependenciesInput) => stream.Stream<ListServiceDependenciesOutput, ListServiceDependenciesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceDependenciesInput) => stream.Stream<ServiceDependency, ListServiceDependenciesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServiceDependentsError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns the list of dependents that invoked the specified service during the provided time range. Dependents include other services, CloudWatch Synthetics canaries, and clients that are instrumented with CloudWatch RUM app monitors.
 */
export declare const listServiceDependents: API.OperationMethod<ListServiceDependentsInput, ListServiceDependentsOutput, ListServiceDependentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceDependentsInput) => stream.Stream<ListServiceDependentsOutput, ListServiceDependentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceDependentsInput) => stream.Stream<ServiceDependent, ListServiceDependentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServiceLevelObjectiveExclusionWindowsError = ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves all exclusion windows configured for a specific SLO.
 */
export declare const listServiceLevelObjectiveExclusionWindows: API.OperationMethod<ListServiceLevelObjectiveExclusionWindowsInput, ListServiceLevelObjectiveExclusionWindowsOutput, ListServiceLevelObjectiveExclusionWindowsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceLevelObjectiveExclusionWindowsInput) => stream.Stream<ListServiceLevelObjectiveExclusionWindowsOutput, ListServiceLevelObjectiveExclusionWindowsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceLevelObjectiveExclusionWindowsInput) => stream.Stream<ExclusionWindow, ListServiceLevelObjectiveExclusionWindowsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServiceOperationsError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of the *operations* of this service that have been discovered by Application Signals. Only the operations that were invoked during the specified time range are returned.
 */
export declare const listServiceOperations: API.OperationMethod<ListServiceOperationsInput, ListServiceOperationsOutput, ListServiceOperationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceOperationsInput) => stream.Stream<ListServiceOperationsOutput, ListServiceOperationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceOperationsInput) => stream.Stream<ServiceOperation, ListServiceOperationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServicesError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of services that have been discovered by Application Signals. A service represents a minimum logical and transactional unit that completes a business function. Services are discovered through Application Signals instrumentation.
 */
export declare const listServices: API.OperationMethod<ListServicesInput, ListServicesOutput, ListServicesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServicesInput) => stream.Stream<ListServicesOutput, ListServicesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServicesInput) => stream.Stream<ServiceSummary, ListServicesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListServiceStatesError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about the last deployment and other change states of services. This API provides visibility into recent changes that may have affected service performance, helping with troubleshooting and change correlation.
 */
export declare const listServiceStates: API.OperationMethod<ListServiceStatesInput, ListServiceStatesOutput, ListServiceStatesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceStatesInput) => stream.Stream<ListServiceStatesOutput, ListServiceStatesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceStatesInput) => stream.Stream<ServiceState, ListServiceStatesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Displays the tags associated with a CloudWatch resource. Tags can be assigned to service level objectives.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PutGroupingConfigurationError = AccessDeniedException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates or updates the grouping configuration for this account. This operation allows you to define custom grouping attributes that determine how services are logically grouped based on telemetry attributes, Amazon Web Services tags, or predefined mappings. These grouping attributes can then be used to organize and filter services in the Application Signals console and APIs.
 */
export declare const putGroupingConfiguration: API.OperationMethod<PutGroupingConfigurationInput, PutGroupingConfigurationOutput, PutGroupingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type StartDiscoveryError = AccessDeniedException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Enables this Amazon Web Services account to be able to use CloudWatch Application Signals by creating the *AWSServiceRoleForCloudWatchApplicationSignals* service-linked role. This service- linked role has the following permissions:
 *
 * - `xray:GetServiceGraph`
 *
 * - `logs:StartQuery`
 *
 * - `logs:GetQueryResults`
 *
 * - `cloudwatch:GetMetricData`
 *
 * - `cloudwatch:ListMetrics`
 *
 * - `tag:GetResources`
 *
 * - `autoscaling:DescribeAutoScalingGroups`
 *
 * A service-linked CloudTrail event channel is created to process CloudTrail events and return change event information. This includes last deployment time, userName, eventName, and other event metadata.
 *
 * After completing this step, you still need to instrument your Java and Python applications to send data to Application Signals. For more information, see Enabling Application Signals.
 */
export declare const startDiscovery: API.OperationMethod<StartDiscoveryInput, StartDiscoveryOutput, StartDiscoveryError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | CommonErrors;
/**
 * Assigns one or more tags (key-value pairs) to the specified CloudWatch resource, such as a service level objective.
 *
 * Tags can help you organize and categorize your resources. You can also use them to scope user permissions by granting a user permission to access or change only resources with certain tag values.
 *
 * Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of characters.
 *
 * You can use the `TagResource` action with an alarm that already has tags. If you specify a new tag key for the alarm, this tag is appended to the list of tags associated with the alarm. If you specify a tag key that is already associated with the alarm, the new tag value that you specify replaces the previous value for that tag.
 *
 * You can associate as many as 50 tags with a CloudWatch resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Removes one or more tags from the specified resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateServiceLevelObjectiveError = AccessDeniedException | ConflictException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a service level objective (SLO), which can help you ensure that your critical business operations are meeting customer expectations. Use SLOs to set and track specific target levels for the reliability and availability of your applications and services. SLOs use service level indicators (SLIs) to calculate whether the application is performing at the level that you want.
 *
 * Create an SLO to set a target for a service or operation’s availability or latency. CloudWatch measures this target frequently you can find whether it has been breached.
 *
 * The target performance quality that is defined for an SLO is the *attainment goal*.
 *
 * You can set SLO targets for your applications that are discovered by Application Signals, using critical metrics such as latency and availability. You can also set SLOs against any CloudWatch metric or math expression that produces a time series.
 *
 * You can't create an SLO for a service operation that was discovered by Application Signals until after that operation has reported standard metrics to Application Signals.
 *
 * When you create an SLO, you specify whether it is a *period-based SLO* or a *request-based SLO*. Each type of SLO has a different way of evaluating your application's performance against its attainment goal.
 *
 * - A *period-based SLO* uses defined *periods* of time within a specified total time interval. For each period of time, Application Signals determines whether the application met its goal. The attainment rate is calculated as the `number of good periods/number of total periods`.
 *
 * For example, for a period-based SLO, meeting an attainment goal of 99.9% means that within your interval, your application must meet its performance goal during at least 99.9% of the time periods.
 *
 * - A *request-based SLO* doesn't use pre-defined periods of time. Instead, the SLO measures `number of good requests/number of total requests` during the interval. At any time, you can find the ratio of good requests to total requests for the interval up to the time stamp that you specify, and measure that ratio against the goal set in your SLO.
 *
 * After you have created an SLO, you can retrieve error budget reports for it. An *error budget* is the amount of time or amount of requests that your application can be non-compliant with the SLO's goal, and still have your application meet the goal.
 *
 * - For a period-based SLO, the error budget starts at a number defined by the highest number of periods that can fail to meet the threshold, while still meeting the overall goal. The *remaining error budget* decreases with every failed period that is recorded. The error budget within one interval can never increase.
 *
 * For example, an SLO with a threshold that 99.95% of requests must be completed under 2000ms every month translates to an error budget of 21.9 minutes of downtime per month.
 *
 * - For a request-based SLO, the remaining error budget is dynamic and can increase or decrease, depending on the ratio of good requests to total requests.
 *
 * For more information about SLOs, see Service level objectives (SLOs).
 *
 * When you perform a `CreateServiceLevelObjective` operation, Application Signals creates the *AWSServiceRoleForCloudWatchApplicationSignals* service-linked role, if it doesn't already exist in your account. This service- linked role has the following permissions:
 *
 * - `xray:GetServiceGraph`
 *
 * - `logs:StartQuery`
 *
 * - `logs:GetQueryResults`
 *
 * - `cloudwatch:GetMetricData`
 *
 * - `cloudwatch:ListMetrics`
 *
 * - `tag:GetResources`
 *
 * - `autoscaling:DescribeAutoScalingGroups`
 */
export declare const createServiceLevelObjective: API.OperationMethod<CreateServiceLevelObjectiveInput, CreateServiceLevelObjectiveOutput, CreateServiceLevelObjectiveError, Credentials | Region | HttpClient.HttpClient>;
export type GetServiceLevelObjectiveError = ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about one SLO created in the account.
 */
export declare const getServiceLevelObjective: API.OperationMethod<GetServiceLevelObjectiveInput, GetServiceLevelObjectiveOutput, GetServiceLevelObjectiveError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateServiceLevelObjectiveError = ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an existing service level objective (SLO). If you omit parameters, the previous values of those parameters are retained.
 *
 * You cannot change from a period-based SLO to a request-based SLO, or change from a request-based SLO to a period-based SLO.
 */
export declare const updateServiceLevelObjective: API.OperationMethod<UpdateServiceLevelObjectiveInput, UpdateServiceLevelObjectiveOutput, UpdateServiceLevelObjectiveError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteServiceLevelObjectiveError = ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes the specified service level objective.
 */
export declare const deleteServiceLevelObjective: API.OperationMethod<DeleteServiceLevelObjectiveInput, DeleteServiceLevelObjectiveOutput, DeleteServiceLevelObjectiveError, Credentials | Region | HttpClient.HttpClient>;
export type ListServiceLevelObjectivesError = ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of SLOs created in this account.
 */
export declare const listServiceLevelObjectives: API.OperationMethod<ListServiceLevelObjectivesInput, ListServiceLevelObjectivesOutput, ListServiceLevelObjectivesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServiceLevelObjectivesInput) => stream.Stream<ListServiceLevelObjectivesOutput, ListServiceLevelObjectivesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServiceLevelObjectivesInput) => stream.Stream<ServiceLevelObjectiveSummary, ListServiceLevelObjectivesError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=application-signals.d.ts.map