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 TagKey = string;
export type TagValue = string;
export type ValidationExceptionReason = string;
export type ScraperAlias = string;
export type ClusterArn = string;
export type SecurityGroupId = string;
export type SubnetId = string;
export type WorkspaceArn = string;
export type IamRoleArn = string;
export type IdempotencyToken = string;
export type ScraperId = string;
export type ScraperArn = string;
export type ScraperStatusCode = string;
export type StatusReason = string;
export type FilterKey = string;
export type FilterValue = string;
export type PaginationToken = string;
export type LogGroupArn = string;
export type ScraperComponentType = string;
export type ScraperLoggingConfigurationStatusCode = string;
export type WorkspaceAlias = string;
export type KmsKeyArn = string;
export type WorkspaceId = string;
export type WorkspaceStatusCode = string;
export type Uri = string;
export type AlertManagerDefinitionData = Uint8Array;
export type AlertManagerDefinitionStatusCode = string;
export type AnomalyDetectorAlias = string;
export type AnomalyDetectorEvaluationInterval = number;
export type RandomCutForestQuery = string;
export type PrometheusMetricLabelKey = string;
export type PrometheusMetricLabelValue = string;
export type AnomalyDetectorId = string;
export type AnomalyDetectorArn = string;
export type LoggingConfigurationStatusCode = string;
export type QueryLoggingConfigurationStatusCode = string;
export type RuleGroupsNamespaceName = string;
export type RuleGroupsNamespaceData = Uint8Array;
export type RuleGroupsNamespaceArn = string;
export type RuleGroupsNamespaceStatusCode = string;
export type WorkspaceConfigurationStatusCode = string;
export type LabelName = string;
export type LabelValue = string;
export type WorkspacePolicyStatusCode = string;
export interface GetDefaultScraperConfigurationRequest {
}
export declare const GetDefaultScraperConfigurationRequest: S.Schema<GetDefaultScraperConfigurationRequest>;
export interface GetDefaultScraperConfigurationResponse {
    configuration: Uint8Array;
}
export declare const GetDefaultScraperConfigurationResponse: S.Schema<GetDefaultScraperConfigurationResponse>;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface ValidationExceptionField {
    name: string;
    message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeys = string[];
export declare const TagKeys: 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 type ScrapeConfiguration = {
    configurationBlob: Uint8Array;
};
export declare const ScrapeConfiguration: S.Union<readonly [S.Struct<{
    readonly configurationBlob: S.decodeTo<S.instanceOf<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, S.String, never, never>;
}>]>;
export type SecurityGroupIds = string[];
export declare const SecurityGroupIds: S.$Array<S.String>;
export type SubnetIds = string[];
export declare const SubnetIds: S.$Array<S.String>;
export interface EksConfiguration {
    clusterArn: string;
    securityGroupIds?: string[];
    subnetIds: string[];
}
export declare const EksConfiguration: S.Schema<EksConfiguration>;
export interface VpcConfiguration {
    securityGroupIds: string[];
    subnetIds: string[];
}
export declare const VpcConfiguration: S.Schema<VpcConfiguration>;
export type Source = {
    eksConfiguration: EksConfiguration;
    vpcConfiguration?: never;
} | {
    eksConfiguration?: never;
    vpcConfiguration: VpcConfiguration;
};
export declare const Source: S.Union<readonly [S.Struct<{
    readonly eksConfiguration: S.Schema<EksConfiguration>;
}>, S.Struct<{
    readonly vpcConfiguration: S.Schema<VpcConfiguration>;
}>]>;
export interface AmpConfiguration {
    workspaceArn: string;
}
export declare const AmpConfiguration: S.Schema<AmpConfiguration>;
export type Destination = {
    ampConfiguration: AmpConfiguration;
};
export declare const Destination: S.Union<readonly [S.Struct<{
    readonly ampConfiguration: S.Schema<AmpConfiguration>;
}>]>;
export interface RoleConfiguration {
    sourceRoleArn?: string;
    targetRoleArn?: string;
}
export declare const RoleConfiguration: S.Schema<RoleConfiguration>;
export interface CreateScraperRequest {
    alias?: string;
    scrapeConfiguration: ScrapeConfiguration;
    source: Source;
    destination: Destination;
    roleConfiguration?: RoleConfiguration;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateScraperRequest: S.Schema<CreateScraperRequest>;
export interface ScraperStatus {
    statusCode: string;
}
export declare const ScraperStatus: S.Schema<ScraperStatus>;
export interface CreateScraperResponse {
    scraperId: string;
    arn: string;
    status: ScraperStatus;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateScraperResponse: S.Schema<CreateScraperResponse>;
export interface DescribeScraperRequest {
    scraperId: string;
}
export declare const DescribeScraperRequest: S.Schema<DescribeScraperRequest>;
export interface ScraperDescription {
    alias?: string;
    scraperId: string;
    arn: string;
    roleArn: string;
    status: ScraperStatus;
    createdAt: Date;
    lastModifiedAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
    statusReason?: string;
    scrapeConfiguration: ScrapeConfiguration;
    source: Source;
    destination: Destination;
    roleConfiguration?: RoleConfiguration;
}
export declare const ScraperDescription: S.Schema<ScraperDescription>;
export interface DescribeScraperResponse {
    scraper: ScraperDescription;
}
export declare const DescribeScraperResponse: S.Schema<DescribeScraperResponse>;
export interface UpdateScraperRequest {
    scraperId: string;
    alias?: string;
    scrapeConfiguration?: ScrapeConfiguration;
    destination?: Destination;
    roleConfiguration?: RoleConfiguration;
    clientToken?: string;
}
export declare const UpdateScraperRequest: S.Schema<UpdateScraperRequest>;
export interface UpdateScraperResponse {
    scraperId: string;
    arn: string;
    status: ScraperStatus;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const UpdateScraperResponse: S.Schema<UpdateScraperResponse>;
export interface DeleteScraperRequest {
    scraperId: string;
    clientToken?: string;
}
export declare const DeleteScraperRequest: S.Schema<DeleteScraperRequest>;
export interface DeleteScraperResponse {
    scraperId: string;
    status: ScraperStatus;
}
export declare const DeleteScraperResponse: S.Schema<DeleteScraperResponse>;
export type FilterValues = string[];
export declare const FilterValues: S.$Array<S.String>;
export type ScraperFilters = {
    [key: string]: string[] | undefined;
};
export declare const ScraperFilters: S.$Record<S.String, S.optional<S.$Array<S.String>>>;
export interface ListScrapersRequest {
    filters?: {
        [key: string]: string[] | undefined;
    };
    nextToken?: string;
    maxResults?: number;
}
export declare const ListScrapersRequest: S.Schema<ListScrapersRequest>;
export interface ScraperSummary {
    alias?: string;
    scraperId: string;
    arn: string;
    roleArn: string;
    status: ScraperStatus;
    createdAt: Date;
    lastModifiedAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
    statusReason?: string;
    source: Source;
    destination: Destination;
    roleConfiguration?: RoleConfiguration;
}
export declare const ScraperSummary: S.Schema<ScraperSummary>;
export type ScraperSummaryList = ScraperSummary[];
export declare const ScraperSummaryList: S.$Array<S.Schema<ScraperSummary>>;
export interface ListScrapersResponse {
    scrapers: ScraperSummary[];
    nextToken?: string;
}
export declare const ListScrapersResponse: S.Schema<ListScrapersResponse>;
export interface CloudWatchLogDestination {
    logGroupArn: string;
}
export declare const CloudWatchLogDestination: S.Schema<CloudWatchLogDestination>;
export type ScraperLoggingDestination = {
    cloudWatchLogs: CloudWatchLogDestination;
};
export declare const ScraperLoggingDestination: S.Union<readonly [S.Struct<{
    readonly cloudWatchLogs: S.Schema<CloudWatchLogDestination>;
}>]>;
export type StringMap = {
    [key: string]: string | undefined;
};
export declare const StringMap: S.$Record<S.String, S.optional<S.String>>;
export interface ComponentConfig {
    options?: {
        [key: string]: string | undefined;
    };
}
export declare const ComponentConfig: S.Schema<ComponentConfig>;
export interface ScraperComponent {
    type: string;
    config?: ComponentConfig;
}
export declare const ScraperComponent: S.Schema<ScraperComponent>;
export type ScraperComponents = ScraperComponent[];
export declare const ScraperComponents: S.$Array<S.Schema<ScraperComponent>>;
export interface UpdateScraperLoggingConfigurationRequest {
    scraperId: string;
    loggingDestination: ScraperLoggingDestination;
    scraperComponents?: ScraperComponent[];
}
export declare const UpdateScraperLoggingConfigurationRequest: S.Schema<UpdateScraperLoggingConfigurationRequest>;
export interface ScraperLoggingConfigurationStatus {
    statusCode: string;
    statusReason?: string;
}
export declare const ScraperLoggingConfigurationStatus: S.Schema<ScraperLoggingConfigurationStatus>;
export interface UpdateScraperLoggingConfigurationResponse {
    status: ScraperLoggingConfigurationStatus;
}
export declare const UpdateScraperLoggingConfigurationResponse: S.Schema<UpdateScraperLoggingConfigurationResponse>;
export interface DescribeScraperLoggingConfigurationRequest {
    scraperId: string;
}
export declare const DescribeScraperLoggingConfigurationRequest: S.Schema<DescribeScraperLoggingConfigurationRequest>;
export interface DescribeScraperLoggingConfigurationResponse {
    status: ScraperLoggingConfigurationStatus;
    scraperId: string;
    loggingDestination: ScraperLoggingDestination;
    scraperComponents: ScraperComponent[];
    modifiedAt: Date;
}
export declare const DescribeScraperLoggingConfigurationResponse: S.Schema<DescribeScraperLoggingConfigurationResponse>;
export interface DeleteScraperLoggingConfigurationRequest {
    scraperId: string;
    clientToken?: string;
}
export declare const DeleteScraperLoggingConfigurationRequest: S.Schema<DeleteScraperLoggingConfigurationRequest>;
export interface DeleteScraperLoggingConfigurationResponse {
}
export declare const DeleteScraperLoggingConfigurationResponse: S.Schema<DeleteScraperLoggingConfigurationResponse>;
export interface CreateWorkspaceRequest {
    alias?: string;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
    kmsKeyArn?: string;
}
export declare const CreateWorkspaceRequest: S.Schema<CreateWorkspaceRequest>;
export interface WorkspaceStatus {
    statusCode: string;
}
export declare const WorkspaceStatus: S.Schema<WorkspaceStatus>;
export interface CreateWorkspaceResponse {
    workspaceId: string;
    arn: string;
    status: WorkspaceStatus;
    tags?: {
        [key: string]: string | undefined;
    };
    kmsKeyArn?: string;
}
export declare const CreateWorkspaceResponse: S.Schema<CreateWorkspaceResponse>;
export interface DescribeWorkspaceRequest {
    workspaceId: string;
}
export declare const DescribeWorkspaceRequest: S.Schema<DescribeWorkspaceRequest>;
export interface WorkspaceDescription {
    workspaceId: string;
    alias?: string;
    arn: string;
    status: WorkspaceStatus;
    prometheusEndpoint?: string;
    createdAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
    kmsKeyArn?: string;
}
export declare const WorkspaceDescription: S.Schema<WorkspaceDescription>;
export interface DescribeWorkspaceResponse {
    workspace: WorkspaceDescription;
}
export declare const DescribeWorkspaceResponse: S.Schema<DescribeWorkspaceResponse>;
export interface UpdateWorkspaceAliasRequest {
    workspaceId: string;
    alias?: string;
    clientToken?: string;
}
export declare const UpdateWorkspaceAliasRequest: S.Schema<UpdateWorkspaceAliasRequest>;
export interface UpdateWorkspaceAliasResponse {
}
export declare const UpdateWorkspaceAliasResponse: S.Schema<UpdateWorkspaceAliasResponse>;
export interface DeleteWorkspaceRequest {
    workspaceId: string;
    clientToken?: string;
}
export declare const DeleteWorkspaceRequest: S.Schema<DeleteWorkspaceRequest>;
export interface DeleteWorkspaceResponse {
}
export declare const DeleteWorkspaceResponse: S.Schema<DeleteWorkspaceResponse>;
export interface ListWorkspacesRequest {
    nextToken?: string;
    alias?: string;
    maxResults?: number;
}
export declare const ListWorkspacesRequest: S.Schema<ListWorkspacesRequest>;
export interface WorkspaceSummary {
    workspaceId: string;
    alias?: string;
    arn: string;
    status: WorkspaceStatus;
    createdAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
    kmsKeyArn?: string;
}
export declare const WorkspaceSummary: S.Schema<WorkspaceSummary>;
export type WorkspaceSummaryList = WorkspaceSummary[];
export declare const WorkspaceSummaryList: S.$Array<S.Schema<WorkspaceSummary>>;
export interface ListWorkspacesResponse {
    workspaces: WorkspaceSummary[];
    nextToken?: string;
}
export declare const ListWorkspacesResponse: S.Schema<ListWorkspacesResponse>;
export interface CreateAlertManagerDefinitionRequest {
    workspaceId: string;
    data: Uint8Array;
    clientToken?: string;
}
export declare const CreateAlertManagerDefinitionRequest: S.Schema<CreateAlertManagerDefinitionRequest>;
export interface AlertManagerDefinitionStatus {
    statusCode: string;
    statusReason?: string;
}
export declare const AlertManagerDefinitionStatus: S.Schema<AlertManagerDefinitionStatus>;
export interface CreateAlertManagerDefinitionResponse {
    status: AlertManagerDefinitionStatus;
}
export declare const CreateAlertManagerDefinitionResponse: S.Schema<CreateAlertManagerDefinitionResponse>;
export interface DescribeAlertManagerDefinitionRequest {
    workspaceId: string;
}
export declare const DescribeAlertManagerDefinitionRequest: S.Schema<DescribeAlertManagerDefinitionRequest>;
export interface AlertManagerDefinitionDescription {
    status: AlertManagerDefinitionStatus;
    data: Uint8Array;
    createdAt: Date;
    modifiedAt: Date;
}
export declare const AlertManagerDefinitionDescription: S.Schema<AlertManagerDefinitionDescription>;
export interface DescribeAlertManagerDefinitionResponse {
    alertManagerDefinition: AlertManagerDefinitionDescription;
}
export declare const DescribeAlertManagerDefinitionResponse: S.Schema<DescribeAlertManagerDefinitionResponse>;
export interface PutAlertManagerDefinitionRequest {
    workspaceId: string;
    data: Uint8Array;
    clientToken?: string;
}
export declare const PutAlertManagerDefinitionRequest: S.Schema<PutAlertManagerDefinitionRequest>;
export interface PutAlertManagerDefinitionResponse {
    status: AlertManagerDefinitionStatus;
}
export declare const PutAlertManagerDefinitionResponse: S.Schema<PutAlertManagerDefinitionResponse>;
export interface DeleteAlertManagerDefinitionRequest {
    workspaceId: string;
    clientToken?: string;
}
export declare const DeleteAlertManagerDefinitionRequest: S.Schema<DeleteAlertManagerDefinitionRequest>;
export interface DeleteAlertManagerDefinitionResponse {
}
export declare const DeleteAlertManagerDefinitionResponse: S.Schema<DeleteAlertManagerDefinitionResponse>;
export type AnomalyDetectorMissingDataAction = {
    markAsAnomaly: boolean;
    skip?: never;
} | {
    markAsAnomaly?: never;
    skip: boolean;
};
export declare const AnomalyDetectorMissingDataAction: S.Union<readonly [S.Struct<{
    readonly markAsAnomaly: S.Boolean;
}>, S.Struct<{
    readonly skip: S.Boolean;
}>]>;
export type IgnoreNearExpected = {
    amount: number;
    ratio?: never;
} | {
    amount?: never;
    ratio: number;
};
export declare const IgnoreNearExpected: S.Union<readonly [S.Struct<{
    readonly amount: S.Number;
}>, S.Struct<{
    readonly ratio: S.Number;
}>]>;
export interface RandomCutForestConfiguration {
    query: string;
    shingleSize?: number;
    sampleSize?: number;
    ignoreNearExpectedFromAbove?: IgnoreNearExpected;
    ignoreNearExpectedFromBelow?: IgnoreNearExpected;
}
export declare const RandomCutForestConfiguration: S.Schema<RandomCutForestConfiguration>;
export type AnomalyDetectorConfiguration = {
    randomCutForest: RandomCutForestConfiguration;
};
export declare const AnomalyDetectorConfiguration: S.Union<readonly [S.Struct<{
    readonly randomCutForest: S.Schema<RandomCutForestConfiguration>;
}>]>;
export type PrometheusMetricLabelMap = {
    [key: string]: string | undefined;
};
export declare const PrometheusMetricLabelMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateAnomalyDetectorRequest {
    workspaceId: string;
    alias: string;
    evaluationIntervalInSeconds?: number;
    missingDataAction?: AnomalyDetectorMissingDataAction;
    configuration: AnomalyDetectorConfiguration;
    labels?: {
        [key: string]: string | undefined;
    };
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateAnomalyDetectorRequest: S.Schema<CreateAnomalyDetectorRequest>;
export type AnomalyDetectorStatusCode = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | "CREATION_FAILED" | "UPDATE_FAILED" | "DELETION_FAILED" | (string & {});
export declare const AnomalyDetectorStatusCode: S.String;
export interface AnomalyDetectorStatus {
    statusCode: AnomalyDetectorStatusCode;
    statusReason?: string;
}
export declare const AnomalyDetectorStatus: S.Schema<AnomalyDetectorStatus>;
export interface CreateAnomalyDetectorResponse {
    anomalyDetectorId: string;
    arn: string;
    status: AnomalyDetectorStatus;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateAnomalyDetectorResponse: S.Schema<CreateAnomalyDetectorResponse>;
export interface PutAnomalyDetectorRequest {
    workspaceId: string;
    anomalyDetectorId: string;
    evaluationIntervalInSeconds?: number;
    missingDataAction?: AnomalyDetectorMissingDataAction;
    configuration: AnomalyDetectorConfiguration;
    labels?: {
        [key: string]: string | undefined;
    };
    clientToken?: string;
}
export declare const PutAnomalyDetectorRequest: S.Schema<PutAnomalyDetectorRequest>;
export interface PutAnomalyDetectorResponse {
    anomalyDetectorId: string;
    arn: string;
    status: AnomalyDetectorStatus;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const PutAnomalyDetectorResponse: S.Schema<PutAnomalyDetectorResponse>;
export interface DescribeAnomalyDetectorRequest {
    workspaceId: string;
    anomalyDetectorId: string;
}
export declare const DescribeAnomalyDetectorRequest: S.Schema<DescribeAnomalyDetectorRequest>;
export interface AnomalyDetectorDescription {
    arn: string;
    anomalyDetectorId: string;
    alias: string;
    evaluationIntervalInSeconds?: number;
    missingDataAction?: AnomalyDetectorMissingDataAction;
    configuration?: AnomalyDetectorConfiguration;
    labels?: {
        [key: string]: string | undefined;
    };
    status: AnomalyDetectorStatus;
    createdAt: Date;
    modifiedAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const AnomalyDetectorDescription: S.Schema<AnomalyDetectorDescription>;
export interface DescribeAnomalyDetectorResponse {
    anomalyDetector: AnomalyDetectorDescription;
}
export declare const DescribeAnomalyDetectorResponse: S.Schema<DescribeAnomalyDetectorResponse>;
export interface DeleteAnomalyDetectorRequest {
    workspaceId: string;
    anomalyDetectorId: string;
    clientToken?: string;
}
export declare const DeleteAnomalyDetectorRequest: S.Schema<DeleteAnomalyDetectorRequest>;
export interface DeleteAnomalyDetectorResponse {
}
export declare const DeleteAnomalyDetectorResponse: S.Schema<DeleteAnomalyDetectorResponse>;
export interface ListAnomalyDetectorsRequest {
    workspaceId: string;
    alias?: string;
    maxResults?: number;
    nextToken?: string;
}
export declare const ListAnomalyDetectorsRequest: S.Schema<ListAnomalyDetectorsRequest>;
export interface AnomalyDetectorSummary {
    arn: string;
    anomalyDetectorId: string;
    alias: string;
    status: AnomalyDetectorStatus;
    createdAt: Date;
    modifiedAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const AnomalyDetectorSummary: S.Schema<AnomalyDetectorSummary>;
export type AnomalyDetectorSummaryList = AnomalyDetectorSummary[];
export declare const AnomalyDetectorSummaryList: S.$Array<S.Schema<AnomalyDetectorSummary>>;
export interface ListAnomalyDetectorsResponse {
    anomalyDetectors: AnomalyDetectorSummary[];
    nextToken?: string;
}
export declare const ListAnomalyDetectorsResponse: S.Schema<ListAnomalyDetectorsResponse>;
export interface CreateLoggingConfigurationRequest {
    workspaceId: string;
    logGroupArn: string;
    clientToken?: string;
}
export declare const CreateLoggingConfigurationRequest: S.Schema<CreateLoggingConfigurationRequest>;
export interface LoggingConfigurationStatus {
    statusCode: string;
    statusReason?: string;
}
export declare const LoggingConfigurationStatus: S.Schema<LoggingConfigurationStatus>;
export interface CreateLoggingConfigurationResponse {
    status: LoggingConfigurationStatus;
}
export declare const CreateLoggingConfigurationResponse: S.Schema<CreateLoggingConfigurationResponse>;
export interface DescribeLoggingConfigurationRequest {
    workspaceId: string;
}
export declare const DescribeLoggingConfigurationRequest: S.Schema<DescribeLoggingConfigurationRequest>;
export interface LoggingConfigurationMetadata {
    status: LoggingConfigurationStatus;
    workspace: string;
    logGroupArn: string;
    createdAt: Date;
    modifiedAt: Date;
}
export declare const LoggingConfigurationMetadata: S.Schema<LoggingConfigurationMetadata>;
export interface DescribeLoggingConfigurationResponse {
    loggingConfiguration: LoggingConfigurationMetadata;
}
export declare const DescribeLoggingConfigurationResponse: S.Schema<DescribeLoggingConfigurationResponse>;
export interface UpdateLoggingConfigurationRequest {
    workspaceId: string;
    logGroupArn: string;
    clientToken?: string;
}
export declare const UpdateLoggingConfigurationRequest: S.Schema<UpdateLoggingConfigurationRequest>;
export interface UpdateLoggingConfigurationResponse {
    status: LoggingConfigurationStatus;
}
export declare const UpdateLoggingConfigurationResponse: S.Schema<UpdateLoggingConfigurationResponse>;
export interface DeleteLoggingConfigurationRequest {
    workspaceId: string;
    clientToken?: string;
}
export declare const DeleteLoggingConfigurationRequest: S.Schema<DeleteLoggingConfigurationRequest>;
export interface DeleteLoggingConfigurationResponse {
}
export declare const DeleteLoggingConfigurationResponse: S.Schema<DeleteLoggingConfigurationResponse>;
export interface LoggingFilter {
    qspThreshold: number;
}
export declare const LoggingFilter: S.Schema<LoggingFilter>;
export interface LoggingDestination {
    cloudWatchLogs: CloudWatchLogDestination;
    filters: LoggingFilter;
}
export declare const LoggingDestination: S.Schema<LoggingDestination>;
export type LoggingDestinations = LoggingDestination[];
export declare const LoggingDestinations: S.$Array<S.Schema<LoggingDestination>>;
export interface CreateQueryLoggingConfigurationRequest {
    workspaceId: string;
    destinations: LoggingDestination[];
    clientToken?: string;
}
export declare const CreateQueryLoggingConfigurationRequest: S.Schema<CreateQueryLoggingConfigurationRequest>;
export interface QueryLoggingConfigurationStatus {
    statusCode: string;
    statusReason?: string;
}
export declare const QueryLoggingConfigurationStatus: S.Schema<QueryLoggingConfigurationStatus>;
export interface CreateQueryLoggingConfigurationResponse {
    status: QueryLoggingConfigurationStatus;
}
export declare const CreateQueryLoggingConfigurationResponse: S.Schema<CreateQueryLoggingConfigurationResponse>;
export interface DescribeQueryLoggingConfigurationRequest {
    workspaceId: string;
}
export declare const DescribeQueryLoggingConfigurationRequest: S.Schema<DescribeQueryLoggingConfigurationRequest>;
export interface QueryLoggingConfigurationMetadata {
    status: QueryLoggingConfigurationStatus;
    workspace: string;
    destinations: LoggingDestination[];
    createdAt: Date;
    modifiedAt: Date;
}
export declare const QueryLoggingConfigurationMetadata: S.Schema<QueryLoggingConfigurationMetadata>;
export interface DescribeQueryLoggingConfigurationResponse {
    queryLoggingConfiguration: QueryLoggingConfigurationMetadata;
}
export declare const DescribeQueryLoggingConfigurationResponse: S.Schema<DescribeQueryLoggingConfigurationResponse>;
export interface UpdateQueryLoggingConfigurationRequest {
    workspaceId: string;
    destinations: LoggingDestination[];
    clientToken?: string;
}
export declare const UpdateQueryLoggingConfigurationRequest: S.Schema<UpdateQueryLoggingConfigurationRequest>;
export interface UpdateQueryLoggingConfigurationResponse {
    status: QueryLoggingConfigurationStatus;
}
export declare const UpdateQueryLoggingConfigurationResponse: S.Schema<UpdateQueryLoggingConfigurationResponse>;
export interface DeleteQueryLoggingConfigurationRequest {
    workspaceId: string;
    clientToken?: string;
}
export declare const DeleteQueryLoggingConfigurationRequest: S.Schema<DeleteQueryLoggingConfigurationRequest>;
export interface DeleteQueryLoggingConfigurationResponse {
}
export declare const DeleteQueryLoggingConfigurationResponse: S.Schema<DeleteQueryLoggingConfigurationResponse>;
export interface CreateRuleGroupsNamespaceRequest {
    workspaceId: string;
    name: string;
    data: Uint8Array;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateRuleGroupsNamespaceRequest: S.Schema<CreateRuleGroupsNamespaceRequest>;
export interface RuleGroupsNamespaceStatus {
    statusCode: string;
    statusReason?: string;
}
export declare const RuleGroupsNamespaceStatus: S.Schema<RuleGroupsNamespaceStatus>;
export interface CreateRuleGroupsNamespaceResponse {
    name: string;
    arn: string;
    status: RuleGroupsNamespaceStatus;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateRuleGroupsNamespaceResponse: S.Schema<CreateRuleGroupsNamespaceResponse>;
export interface DescribeRuleGroupsNamespaceRequest {
    workspaceId: string;
    name: string;
}
export declare const DescribeRuleGroupsNamespaceRequest: S.Schema<DescribeRuleGroupsNamespaceRequest>;
export interface RuleGroupsNamespaceDescription {
    arn: string;
    name: string;
    status: RuleGroupsNamespaceStatus;
    data: Uint8Array;
    createdAt: Date;
    modifiedAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const RuleGroupsNamespaceDescription: S.Schema<RuleGroupsNamespaceDescription>;
export interface DescribeRuleGroupsNamespaceResponse {
    ruleGroupsNamespace: RuleGroupsNamespaceDescription;
}
export declare const DescribeRuleGroupsNamespaceResponse: S.Schema<DescribeRuleGroupsNamespaceResponse>;
export interface PutRuleGroupsNamespaceRequest {
    workspaceId: string;
    name: string;
    data: Uint8Array;
    clientToken?: string;
}
export declare const PutRuleGroupsNamespaceRequest: S.Schema<PutRuleGroupsNamespaceRequest>;
export interface PutRuleGroupsNamespaceResponse {
    name: string;
    arn: string;
    status: RuleGroupsNamespaceStatus;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const PutRuleGroupsNamespaceResponse: S.Schema<PutRuleGroupsNamespaceResponse>;
export interface DeleteRuleGroupsNamespaceRequest {
    workspaceId: string;
    name: string;
    clientToken?: string;
}
export declare const DeleteRuleGroupsNamespaceRequest: S.Schema<DeleteRuleGroupsNamespaceRequest>;
export interface DeleteRuleGroupsNamespaceResponse {
}
export declare const DeleteRuleGroupsNamespaceResponse: S.Schema<DeleteRuleGroupsNamespaceResponse>;
export interface ListRuleGroupsNamespacesRequest {
    workspaceId: string;
    name?: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListRuleGroupsNamespacesRequest: S.Schema<ListRuleGroupsNamespacesRequest>;
export interface RuleGroupsNamespaceSummary {
    arn: string;
    name: string;
    status: RuleGroupsNamespaceStatus;
    createdAt: Date;
    modifiedAt: Date;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const RuleGroupsNamespaceSummary: S.Schema<RuleGroupsNamespaceSummary>;
export type RuleGroupsNamespaceSummaryList = RuleGroupsNamespaceSummary[];
export declare const RuleGroupsNamespaceSummaryList: S.$Array<S.Schema<RuleGroupsNamespaceSummary>>;
export interface ListRuleGroupsNamespacesResponse {
    ruleGroupsNamespaces: RuleGroupsNamespaceSummary[];
    nextToken?: string;
}
export declare const ListRuleGroupsNamespacesResponse: S.Schema<ListRuleGroupsNamespacesResponse>;
export interface DescribeWorkspaceConfigurationRequest {
    workspaceId: string;
}
export declare const DescribeWorkspaceConfigurationRequest: S.Schema<DescribeWorkspaceConfigurationRequest>;
export interface WorkspaceConfigurationStatus {
    statusCode: string;
    statusReason?: string;
}
export declare const WorkspaceConfigurationStatus: S.Schema<WorkspaceConfigurationStatus>;
export interface LimitsPerLabelSetEntry {
    maxSeries?: number;
}
export declare const LimitsPerLabelSetEntry: S.Schema<LimitsPerLabelSetEntry>;
export type LabelSet = {
    [key: string]: string | undefined;
};
export declare const LabelSet: S.$Record<S.String, S.optional<S.String>>;
export interface LimitsPerLabelSet {
    limits: LimitsPerLabelSetEntry;
    labelSet: {
        [key: string]: string | undefined;
    };
}
export declare const LimitsPerLabelSet: S.Schema<LimitsPerLabelSet>;
export type LimitsPerLabelSetList = LimitsPerLabelSet[];
export declare const LimitsPerLabelSetList: S.$Array<S.Schema<LimitsPerLabelSet>>;
export interface WorkspaceConfigurationDescription {
    status: WorkspaceConfigurationStatus;
    limitsPerLabelSet?: LimitsPerLabelSet[];
    retentionPeriodInDays?: number;
}
export declare const WorkspaceConfigurationDescription: S.Schema<WorkspaceConfigurationDescription>;
export interface DescribeWorkspaceConfigurationResponse {
    workspaceConfiguration: WorkspaceConfigurationDescription;
}
export declare const DescribeWorkspaceConfigurationResponse: S.Schema<DescribeWorkspaceConfigurationResponse>;
export interface UpdateWorkspaceConfigurationRequest {
    workspaceId: string;
    clientToken?: string;
    limitsPerLabelSet?: LimitsPerLabelSet[];
    retentionPeriodInDays?: number;
}
export declare const UpdateWorkspaceConfigurationRequest: S.Schema<UpdateWorkspaceConfigurationRequest>;
export interface UpdateWorkspaceConfigurationResponse {
    status: WorkspaceConfigurationStatus;
}
export declare const UpdateWorkspaceConfigurationResponse: S.Schema<UpdateWorkspaceConfigurationResponse>;
export interface PutResourcePolicyRequest {
    workspaceId: string;
    policyDocument: string;
    clientToken?: string;
    revisionId?: string;
}
export declare const PutResourcePolicyRequest: S.Schema<PutResourcePolicyRequest>;
export interface PutResourcePolicyResponse {
    policyStatus: string;
    revisionId: string;
}
export declare const PutResourcePolicyResponse: S.Schema<PutResourcePolicyResponse>;
export interface DescribeResourcePolicyRequest {
    workspaceId: string;
}
export declare const DescribeResourcePolicyRequest: S.Schema<DescribeResourcePolicyRequest>;
export interface DescribeResourcePolicyResponse {
    policyDocument: string;
    policyStatus: string;
    revisionId: string;
}
export declare const DescribeResourcePolicyResponse: S.Schema<DescribeResourcePolicyResponse>;
export interface DeleteResourcePolicyRequest {
    workspaceId: string;
    clientToken?: string;
    revisionId?: string;
}
export declare const DeleteResourcePolicyRequest: S.Schema<DeleteResourcePolicyRequest>;
export interface DeleteResourcePolicyResponse {
}
export declare const DeleteResourcePolicyResponse: S.Schema<DeleteResourcePolicyResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.String;
    readonly retryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.String;
    readonly serviceCode: S.optional<S.String>;
    readonly quotaCode: S.optional<S.String>;
    readonly retryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly reason: S.String;
    readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
    readonly serviceCode: S.String;
    readonly quotaCode: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
export type GetDefaultScraperConfigurationError = AccessDeniedException | InternalServerException | ThrottlingException | CommonErrors;
/**
 * The `GetDefaultScraperConfiguration` operation returns the default scraper configuration used when Amazon EKS creates a scraper for you.
 */
export declare const getDefaultScraperConfiguration: API.OperationMethod<GetDefaultScraperConfigurationRequest, GetDefaultScraperConfigurationResponse, GetDefaultScraperConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `ListTagsForResource` operation returns the tags that are associated with an Amazon Managed Service for Prometheus resource. Currently, the only resources that can be tagged are scrapers, workspaces, and rule groups namespaces.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `TagResource` operation associates tags with an Amazon Managed Service for Prometheus resource. The only resources that can be tagged are rule groups namespaces, scrapers, and workspaces.
 *
 * If you specify a new tag key for the resource, this tag is appended to the list of tags associated with the resource. If you specify a tag key that is already associated with the resource, the new tag value that you specify replaces the previous value for that tag. To remove a tag, use `UntagResource`.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Removes the specified tags from an Amazon Managed Service for Prometheus resource. The only resources that can be tagged are rule groups namespaces, scrapers, and workspaces.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateScraperError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `CreateScraper` operation creates a scraper to collect metrics. A scraper pulls metrics from Prometheus-compatible sources and sends them to your Amazon Managed Service for Prometheus workspace. You can configure scrapers to collect metrics from Amazon EKS clusters, Amazon MSK clusters, or from VPC-based sources that support DNS-based service discovery. Scrapers are flexible, and can be configured to control what metrics are collected, the frequency of collection, what transformations are applied to the metrics, and more.
 *
 * An IAM role will be created for you that Amazon Managed Service for Prometheus uses to access the metrics in your source. You must configure this role with a policy that allows it to scrape metrics from your source. For Amazon EKS sources, see Configuring your Amazon EKS cluster in the *Amazon Managed Service for Prometheus User Guide*.
 *
 * The `scrapeConfiguration` parameter contains the base-64 encoded YAML configuration for the scraper.
 *
 * When creating a scraper, the service creates a `Network Interface` in each **Availability Zone** that are passed into `CreateScraper` through subnets. These network interfaces are used to connect to your source within the VPC for scraping metrics.
 *
 * For more information about collectors, including what metrics are collected, and how to configure the scraper, see Using an Amazon Web Services managed collector in the *Amazon Managed Service for Prometheus User Guide*.
 */
export declare const createScraper: API.OperationMethod<CreateScraperRequest, CreateScraperResponse, CreateScraperError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeScraperError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `DescribeScraper` operation displays information about an existing scraper.
 */
export declare const describeScraper: API.OperationMethod<DescribeScraperRequest, DescribeScraperResponse, DescribeScraperError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateScraperError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an existing scraper.
 *
 * You can't use this function to update the source from which the scraper is collecting metrics. To change the source, delete the scraper and create a new one.
 */
export declare const updateScraper: API.OperationMethod<UpdateScraperRequest, UpdateScraperResponse, UpdateScraperError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteScraperError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `DeleteScraper` operation deletes one scraper, and stops any metrics collection that the scraper performs.
 */
export declare const deleteScraper: API.OperationMethod<DeleteScraperRequest, DeleteScraperResponse, DeleteScraperError, Credentials | Region | HttpClient.HttpClient>;
export type ListScrapersError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `ListScrapers` operation lists all of the scrapers in your account. This includes scrapers being created or deleted. You can optionally filter the returned list.
 */
export declare const listScrapers: API.OperationMethod<ListScrapersRequest, ListScrapersResponse, ListScrapersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListScrapersRequest) => stream.Stream<ListScrapersResponse, ListScrapersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListScrapersRequest) => stream.Stream<ScraperSummary, ListScrapersError, Credentials | Region | HttpClient.HttpClient>;
};
export type UpdateScraperLoggingConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates the logging configuration for a Amazon Managed Service for Prometheus scraper.
 */
export declare const updateScraperLoggingConfiguration: API.OperationMethod<UpdateScraperLoggingConfigurationRequest, UpdateScraperLoggingConfigurationResponse, UpdateScraperLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeScraperLoggingConfigurationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Describes the logging configuration for a Amazon Managed Service for Prometheus scraper.
 */
export declare const describeScraperLoggingConfiguration: API.OperationMethod<DescribeScraperLoggingConfigurationRequest, DescribeScraperLoggingConfigurationResponse, DescribeScraperLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteScraperLoggingConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes the logging configuration for a Amazon Managed Service for Prometheus scraper.
 */
export declare const deleteScraperLoggingConfiguration: API.OperationMethod<DeleteScraperLoggingConfigurationRequest, DeleteScraperLoggingConfigurationResponse, DeleteScraperLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateWorkspaceError = AccessDeniedException | ConflictException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a Prometheus workspace. A workspace is a logical space dedicated to the storage and querying of Prometheus metrics. You can have one or more workspaces in each Region in your account.
 */
export declare const createWorkspace: API.OperationMethod<CreateWorkspaceRequest, CreateWorkspaceResponse, CreateWorkspaceError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeWorkspaceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about an existing workspace.
 */
export declare const describeWorkspace: API.OperationMethod<DescribeWorkspaceRequest, DescribeWorkspaceResponse, DescribeWorkspaceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateWorkspaceAliasError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the alias of an existing workspace.
 */
export declare const updateWorkspaceAlias: API.OperationMethod<UpdateWorkspaceAliasRequest, UpdateWorkspaceAliasResponse, UpdateWorkspaceAliasError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteWorkspaceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes an existing workspace.
 *
 * When you delete a workspace, the data that has been ingested into it is not immediately deleted. It will be permanently deleted within one month.
 */
export declare const deleteWorkspace: API.OperationMethod<DeleteWorkspaceRequest, DeleteWorkspaceResponse, DeleteWorkspaceError, Credentials | Region | HttpClient.HttpClient>;
export type ListWorkspacesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all of the Amazon Managed Service for Prometheus workspaces in your account. This includes workspaces being created or deleted.
 */
export declare const listWorkspaces: API.OperationMethod<ListWorkspacesRequest, ListWorkspacesResponse, ListWorkspacesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListWorkspacesRequest) => stream.Stream<ListWorkspacesResponse, ListWorkspacesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListWorkspacesRequest) => stream.Stream<WorkspaceSummary, ListWorkspacesError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateAlertManagerDefinitionError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `CreateAlertManagerDefinition` operation creates the alert manager definition in a workspace. If a workspace already has an alert manager definition, don't use this operation to update it. Instead, use `PutAlertManagerDefinition`.
 */
export declare const createAlertManagerDefinition: API.OperationMethod<CreateAlertManagerDefinitionRequest, CreateAlertManagerDefinitionResponse, CreateAlertManagerDefinitionError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeAlertManagerDefinitionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves the full information about the alert manager definition for a workspace.
 */
export declare const describeAlertManagerDefinition: API.OperationMethod<DescribeAlertManagerDefinitionRequest, DescribeAlertManagerDefinitionResponse, DescribeAlertManagerDefinitionError, Credentials | Region | HttpClient.HttpClient>;
export type PutAlertManagerDefinitionError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an existing alert manager definition in a workspace. If the workspace does not already have an alert manager definition, don't use this operation to create it. Instead, use `CreateAlertManagerDefinition`.
 */
export declare const putAlertManagerDefinition: API.OperationMethod<PutAlertManagerDefinitionRequest, PutAlertManagerDefinitionResponse, PutAlertManagerDefinitionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteAlertManagerDefinitionError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes the alert manager definition from a workspace.
 */
export declare const deleteAlertManagerDefinition: API.OperationMethod<DeleteAlertManagerDefinitionRequest, DeleteAlertManagerDefinitionResponse, DeleteAlertManagerDefinitionError, Credentials | Region | HttpClient.HttpClient>;
export type CreateAnomalyDetectorError = AccessDeniedException | ConflictException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates an anomaly detector within a workspace using the Random Cut Forest algorithm for time-series analysis. The anomaly detector analyzes Amazon Managed Service for Prometheus metrics to identify unusual patterns and behaviors.
 */
export declare const createAnomalyDetector: API.OperationMethod<CreateAnomalyDetectorRequest, CreateAnomalyDetectorResponse, CreateAnomalyDetectorError, Credentials | Region | HttpClient.HttpClient>;
export type PutAnomalyDetectorError = AccessDeniedException | ConflictException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * When you call `PutAnomalyDetector`, the operation creates a new anomaly detector if one doesn't exist, or updates an existing one. Each call to this operation triggers a complete retraining of the detector, which includes querying the minimum required samples and backfilling the detector with historical data. This process occurs regardless of whether you're making a minor change like updating the evaluation interval or making more substantial modifications. The operation serves as the single method for creating, updating, and retraining anomaly detectors.
 */
export declare const putAnomalyDetector: API.OperationMethod<PutAnomalyDetectorRequest, PutAnomalyDetectorResponse, PutAnomalyDetectorError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeAnomalyDetectorError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves detailed information about a specific anomaly detector, including its status and configuration.
 */
export declare const describeAnomalyDetector: API.OperationMethod<DescribeAnomalyDetectorRequest, DescribeAnomalyDetectorResponse, DescribeAnomalyDetectorError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteAnomalyDetectorError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Removes an anomaly detector from a workspace. This operation is idempotent.
 */
export declare const deleteAnomalyDetector: API.OperationMethod<DeleteAnomalyDetectorRequest, DeleteAnomalyDetectorResponse, DeleteAnomalyDetectorError, Credentials | Region | HttpClient.HttpClient>;
export type ListAnomalyDetectorsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a paginated list of anomaly detectors for a workspace with optional filtering by alias.
 */
export declare const listAnomalyDetectors: API.OperationMethod<ListAnomalyDetectorsRequest, ListAnomalyDetectorsResponse, ListAnomalyDetectorsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAnomalyDetectorsRequest) => stream.Stream<ListAnomalyDetectorsResponse, ListAnomalyDetectorsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAnomalyDetectorsRequest) => stream.Stream<AnomalyDetectorSummary, ListAnomalyDetectorsError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateLoggingConfigurationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * The `CreateLoggingConfiguration` operation creates rules and alerting logging configuration for the workspace. Use this operation to set the CloudWatch log group to which the logs will be published to.
 *
 * These logging configurations are only for rules and alerting logs.
 */
export declare const createLoggingConfiguration: API.OperationMethod<CreateLoggingConfigurationRequest, CreateLoggingConfigurationResponse, CreateLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeLoggingConfigurationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns complete information about the current rules and alerting logging configuration of the workspace.
 *
 * These logging configurations are only for rules and alerting logs.
 */
export declare const describeLoggingConfiguration: API.OperationMethod<DescribeLoggingConfigurationRequest, DescribeLoggingConfigurationResponse, DescribeLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateLoggingConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates the log group ARN or the workspace ID of the current rules and alerting logging configuration.
 *
 * These logging configurations are only for rules and alerting logs.
 */
export declare const updateLoggingConfiguration: API.OperationMethod<UpdateLoggingConfigurationRequest, UpdateLoggingConfigurationResponse, UpdateLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteLoggingConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes the rules and alerting logging configuration for a workspace.
 *
 * These logging configurations are only for rules and alerting logs.
 */
export declare const deleteLoggingConfiguration: API.OperationMethod<DeleteLoggingConfigurationRequest, DeleteLoggingConfigurationResponse, DeleteLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateQueryLoggingConfigurationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Creates a query logging configuration for the specified workspace. This operation enables logging of queries that exceed the specified QSP threshold.
 */
export declare const createQueryLoggingConfiguration: API.OperationMethod<CreateQueryLoggingConfigurationRequest, CreateQueryLoggingConfigurationResponse, CreateQueryLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeQueryLoggingConfigurationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Retrieves the details of the query logging configuration for the specified workspace.
 */
export declare const describeQueryLoggingConfiguration: API.OperationMethod<DescribeQueryLoggingConfigurationRequest, DescribeQueryLoggingConfigurationResponse, DescribeQueryLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateQueryLoggingConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates the query logging configuration for the specified workspace.
 */
export declare const updateQueryLoggingConfiguration: API.OperationMethod<UpdateQueryLoggingConfigurationRequest, UpdateQueryLoggingConfigurationResponse, UpdateQueryLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteQueryLoggingConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes the query logging configuration for the specified workspace.
 */
export declare const deleteQueryLoggingConfiguration: API.OperationMethod<DeleteQueryLoggingConfigurationRequest, DeleteQueryLoggingConfigurationResponse, DeleteQueryLoggingConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateRuleGroupsNamespaceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The `CreateRuleGroupsNamespace` operation creates a rule groups namespace within a workspace. A rule groups namespace is associated with exactly one rules file. A workspace can have multiple rule groups namespaces.
 *
 * The combined length of a rule group namespace and a rule group name cannot exceed 721 UTF-8 bytes.
 *
 * Use this operation only to create new rule groups namespaces. To update an existing rule groups namespace, use `PutRuleGroupsNamespace`.
 */
export declare const createRuleGroupsNamespace: API.OperationMethod<CreateRuleGroupsNamespaceRequest, CreateRuleGroupsNamespaceResponse, CreateRuleGroupsNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeRuleGroupsNamespaceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns complete information about one rule groups namespace. To retrieve a list of rule groups namespaces, use `ListRuleGroupsNamespaces`.
 */
export declare const describeRuleGroupsNamespace: API.OperationMethod<DescribeRuleGroupsNamespaceRequest, DescribeRuleGroupsNamespaceResponse, DescribeRuleGroupsNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type PutRuleGroupsNamespaceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an existing rule groups namespace within a workspace. A rule groups namespace is associated with exactly one rules file. A workspace can have multiple rule groups namespaces.
 *
 * The combined length of a rule group namespace and a rule group name cannot exceed 721 UTF-8 bytes.
 *
 * Use this operation only to update existing rule groups namespaces. To create a new rule groups namespace, use `CreateRuleGroupsNamespace`.
 *
 * You can't use this operation to add tags to an existing rule groups namespace. Instead, use `TagResource`.
 */
export declare const putRuleGroupsNamespace: API.OperationMethod<PutRuleGroupsNamespaceRequest, PutRuleGroupsNamespaceResponse, PutRuleGroupsNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteRuleGroupsNamespaceError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes one rule groups namespace and its associated rule groups definition.
 */
export declare const deleteRuleGroupsNamespace: API.OperationMethod<DeleteRuleGroupsNamespaceRequest, DeleteRuleGroupsNamespaceResponse, DeleteRuleGroupsNamespaceError, Credentials | Region | HttpClient.HttpClient>;
export type ListRuleGroupsNamespacesError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of rule groups namespaces in a workspace.
 */
export declare const listRuleGroupsNamespaces: API.OperationMethod<ListRuleGroupsNamespacesRequest, ListRuleGroupsNamespacesResponse, ListRuleGroupsNamespacesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRuleGroupsNamespacesRequest) => stream.Stream<ListRuleGroupsNamespacesResponse, ListRuleGroupsNamespacesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRuleGroupsNamespacesRequest) => stream.Stream<RuleGroupsNamespaceSummary, ListRuleGroupsNamespacesError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeWorkspaceConfigurationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to return information about the configuration of a workspace. The configuration details returned include workspace configuration status, label set limits, and retention period.
 */
export declare const describeWorkspaceConfiguration: API.OperationMethod<DescribeWorkspaceConfigurationRequest, DescribeWorkspaceConfigurationResponse, DescribeWorkspaceConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateWorkspaceConfigurationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to create or update the label sets, label set limits, and retention period of a workspace.
 *
 * You must specify at least one of `limitsPerLabelSet` or `retentionPeriodInDays` for the request to be valid.
 */
export declare const updateWorkspaceConfiguration: API.OperationMethod<UpdateWorkspaceConfigurationRequest, UpdateWorkspaceConfigurationResponse, UpdateWorkspaceConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type PutResourcePolicyError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates or updates a resource-based policy for an Amazon Managed Service for Prometheus workspace. Use resource-based policies to grant permissions to other AWS accounts or services to access your workspace.
 *
 * Only Prometheus-compatible APIs can be used for workspace sharing. You can add non-Prometheus-compatible APIs to the policy, but they will be ignored. For more information, see Prometheus-compatible APIs in the *Amazon Managed Service for Prometheus User Guide*.
 *
 * If your workspace uses customer-managed KMS keys for encryption, you must grant the principals in your resource-based policy access to those KMS keys. You can do this by creating KMS grants. For more information, see CreateGrant in the *AWS Key Management Service API Reference* and Encryption at rest in the *Amazon Managed Service for Prometheus User Guide*.
 *
 * For more information about working with IAM, see Using Amazon Managed Service for Prometheus with IAM in the *Amazon Managed Service for Prometheus User Guide*.
 */
export declare const putResourcePolicy: API.OperationMethod<PutResourcePolicyRequest, PutResourcePolicyResponse, PutResourcePolicyError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeResourcePolicyError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about the resource-based policy attached to an Amazon Managed Service for Prometheus workspace.
 */
export declare const describeResourcePolicy: API.OperationMethod<DescribeResourcePolicyRequest, DescribeResourcePolicyResponse, DescribeResourcePolicyError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteResourcePolicyError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes the resource-based policy attached to an Amazon Managed Service for Prometheus workspace.
 */
export declare const deleteResourcePolicy: API.OperationMethod<DeleteResourcePolicyRequest, DeleteResourcePolicyResponse, DeleteResourcePolicyError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=amp.d.ts.map