import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
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 IdentifierString = string;
export type ISOTimestamp = Date;
export type TagKey = string;
export type TagValue = string;
export type AnalysisReportId = string;
export type ErrorString = string;
export type RequestString = string;
export type SanitizedString = string;
export type Limit = number;
export type MaxResults = number;
export type NextToken = string;
export type MarkdownString = string | redacted.Redacted<string>;
export type DescriptiveString = string;
export type Description = string;
export type AmazonResourceName = string;
export type ServiceType = "RDS" | "DOCDB" | (string & {});
export declare const ServiceType: S.String;
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 CreatePerformanceAnalysisReportRequest {
    ServiceType: ServiceType;
    Identifier: string;
    StartTime: Date;
    EndTime: Date;
    Tags?: Tag[];
}
export declare const CreatePerformanceAnalysisReportRequest: S.Schema<CreatePerformanceAnalysisReportRequest>;
export interface CreatePerformanceAnalysisReportResponse {
    AnalysisReportId?: string;
}
export declare const CreatePerformanceAnalysisReportResponse: S.Schema<CreatePerformanceAnalysisReportResponse>;
export interface DeletePerformanceAnalysisReportRequest {
    ServiceType: ServiceType;
    Identifier: string;
    AnalysisReportId: string;
}
export declare const DeletePerformanceAnalysisReportRequest: S.Schema<DeletePerformanceAnalysisReportRequest>;
export interface DeletePerformanceAnalysisReportResponse {
}
export declare const DeletePerformanceAnalysisReportResponse: S.Schema<DeletePerformanceAnalysisReportResponse>;
export type SanitizedStringList = string[];
export declare const SanitizedStringList: S.$Array<S.String>;
export interface DimensionGroup {
    Group: string;
    Dimensions?: string[];
    Limit?: number;
}
export declare const DimensionGroup: S.Schema<DimensionGroup>;
export type AdditionalMetricsList = string[];
export declare const AdditionalMetricsList: S.$Array<S.String>;
export type MetricQueryFilterMap = {
    [key: string]: string | undefined;
};
export declare const MetricQueryFilterMap: S.$Record<S.String, S.optional<S.String>>;
export interface DescribeDimensionKeysRequest {
    ServiceType: ServiceType;
    Identifier: string;
    StartTime: Date;
    EndTime: Date;
    Metric: string;
    PeriodInSeconds?: number;
    GroupBy: DimensionGroup;
    AdditionalMetrics?: string[];
    PartitionBy?: DimensionGroup;
    Filter?: {
        [key: string]: string | undefined;
    };
    MaxResults?: number;
    NextToken?: string;
}
export declare const DescribeDimensionKeysRequest: S.Schema<DescribeDimensionKeysRequest>;
export type DimensionMap = {
    [key: string]: string | undefined;
};
export declare const DimensionMap: S.$Record<S.String, S.optional<S.String>>;
export interface ResponsePartitionKey {
    Dimensions: {
        [key: string]: string | undefined;
    };
}
export declare const ResponsePartitionKey: S.Schema<ResponsePartitionKey>;
export type ResponsePartitionKeyList = ResponsePartitionKey[];
export declare const ResponsePartitionKeyList: S.$Array<S.Schema<ResponsePartitionKey>>;
export type AdditionalMetricsMap = {
    [key: string]: number | undefined;
};
export declare const AdditionalMetricsMap: S.$Record<S.String, S.optional<S.Number>>;
export type MetricValuesList = number[];
export declare const MetricValuesList: S.$Array<S.Number>;
export interface DimensionKeyDescription {
    Dimensions?: {
        [key: string]: string | undefined;
    };
    Total?: number;
    AdditionalMetrics?: {
        [key: string]: number | undefined;
    };
    Partitions?: number[];
}
export declare const DimensionKeyDescription: S.Schema<DimensionKeyDescription>;
export type DimensionKeyDescriptionList = DimensionKeyDescription[];
export declare const DimensionKeyDescriptionList: S.$Array<S.Schema<DimensionKeyDescription>>;
export interface DescribeDimensionKeysResponse {
    AlignedStartTime?: Date;
    AlignedEndTime?: Date;
    PartitionKeys?: ResponsePartitionKey[];
    Keys?: DimensionKeyDescription[];
    NextToken?: string;
}
export declare const DescribeDimensionKeysResponse: S.Schema<DescribeDimensionKeysResponse>;
export type RequestedDimensionList = string[];
export declare const RequestedDimensionList: S.$Array<S.String>;
export interface GetDimensionKeyDetailsRequest {
    ServiceType: ServiceType;
    Identifier: string;
    Group: string;
    GroupIdentifier: string;
    RequestedDimensions?: string[];
}
export declare const GetDimensionKeyDetailsRequest: S.Schema<GetDimensionKeyDetailsRequest>;
export type DetailStatus = "AVAILABLE" | "PROCESSING" | "UNAVAILABLE" | (string & {});
export declare const DetailStatus: S.String;
export interface DimensionKeyDetail {
    Value?: string;
    Dimension?: string;
    Status?: DetailStatus;
}
export declare const DimensionKeyDetail: S.Schema<DimensionKeyDetail>;
export type DimensionKeyDetailList = DimensionKeyDetail[];
export declare const DimensionKeyDetailList: S.$Array<S.Schema<DimensionKeyDetail>>;
export interface GetDimensionKeyDetailsResponse {
    Dimensions?: DimensionKeyDetail[];
}
export declare const GetDimensionKeyDetailsResponse: S.Schema<GetDimensionKeyDetailsResponse>;
export type TextFormat = "PLAIN_TEXT" | "MARKDOWN" | (string & {});
export declare const TextFormat: S.String;
export type AcceptLanguage = "EN_US" | (string & {});
export declare const AcceptLanguage: S.String;
export interface GetPerformanceAnalysisReportRequest {
    ServiceType: ServiceType;
    Identifier: string;
    AnalysisReportId: string;
    TextFormat?: TextFormat;
    AcceptLanguage?: AcceptLanguage;
}
export declare const GetPerformanceAnalysisReportRequest: S.Schema<GetPerformanceAnalysisReportRequest>;
export type AnalysisStatus = "RUNNING" | "SUCCEEDED" | "FAILED" | (string & {});
export declare const AnalysisStatus: S.String;
export type ContextType = "CAUSAL" | "CONTEXTUAL" | (string & {});
export declare const ContextType: S.String;
export type Severity = "LOW" | "MEDIUM" | "HIGH" | (string & {});
export declare const Severity: S.String;
export interface Recommendation {
    RecommendationId?: string;
    RecommendationDescription?: string | redacted.Redacted<string>;
}
export declare const Recommendation: S.Schema<Recommendation>;
export type RecommendationList = Recommendation[];
export declare const RecommendationList: S.$Array<S.Schema<Recommendation>>;
export type DescriptiveMap = {
    [key: string]: string | undefined;
};
export declare const DescriptiveMap: S.$Record<S.String, S.optional<S.String>>;
export interface PerformanceInsightsMetric {
    Metric?: string;
    DisplayName?: string;
    Dimensions?: {
        [key: string]: string | undefined;
    };
    Filter?: {
        [key: string]: string | undefined;
    };
    Value?: number;
}
export declare const PerformanceInsightsMetric: S.Schema<PerformanceInsightsMetric>;
export interface Data {
    PerformanceInsightsMetric?: PerformanceInsightsMetric;
}
export declare const Data: S.Schema<Data>;
export type DataList = Data[];
export declare const DataList: S.$Array<S.Schema<Data>>;
export interface Insight {
    InsightId: string;
    InsightType?: string;
    Context?: ContextType;
    StartTime?: Date;
    EndTime?: Date;
    Severity?: Severity;
    SupportingInsights?: Insight[];
    Description?: string | redacted.Redacted<string>;
    Recommendations?: Recommendation[];
    InsightData?: Data[];
    BaselineData?: Data[];
}
export declare const Insight: S.Schema<Insight>;
export type InsightList = Insight[];
export declare const InsightList: S.Schema<InsightList>;
export interface AnalysisReport {
    AnalysisReportId: string;
    Identifier?: string;
    ServiceType?: ServiceType;
    CreateTime?: Date;
    StartTime?: Date;
    EndTime?: Date;
    Status?: AnalysisStatus;
    Insights?: Insight[];
}
export declare const AnalysisReport: S.Schema<AnalysisReport>;
export interface GetPerformanceAnalysisReportResponse {
    AnalysisReport?: AnalysisReport;
}
export declare const GetPerformanceAnalysisReportResponse: S.Schema<GetPerformanceAnalysisReportResponse>;
export interface GetResourceMetadataRequest {
    ServiceType: ServiceType;
    Identifier: string;
}
export declare const GetResourceMetadataRequest: S.Schema<GetResourceMetadataRequest>;
export type FeatureStatus = "ENABLED" | "DISABLED" | "UNSUPPORTED" | "ENABLED_PENDING_REBOOT" | "DISABLED_PENDING_REBOOT" | "UNKNOWN" | (string & {});
export declare const FeatureStatus: S.String;
export interface FeatureMetadata {
    Status?: FeatureStatus;
}
export declare const FeatureMetadata: S.Schema<FeatureMetadata>;
export type FeatureMetadataMap = {
    [key: string]: FeatureMetadata | undefined;
};
export declare const FeatureMetadataMap: S.$Record<S.String, S.optional<S.Schema<FeatureMetadata>>>;
export interface GetResourceMetadataResponse {
    Identifier?: string;
    Features?: {
        [key: string]: FeatureMetadata | undefined;
    };
}
export declare const GetResourceMetadataResponse: S.Schema<GetResourceMetadataResponse>;
export interface MetricQuery {
    Metric: string;
    GroupBy?: DimensionGroup;
    Filter?: {
        [key: string]: string | undefined;
    };
}
export declare const MetricQuery: S.Schema<MetricQuery>;
export type MetricQueryList = MetricQuery[];
export declare const MetricQueryList: S.$Array<S.Schema<MetricQuery>>;
export type PeriodAlignment = "END_TIME" | "START_TIME" | (string & {});
export declare const PeriodAlignment: S.String;
export interface GetResourceMetricsRequest {
    ServiceType: ServiceType;
    Identifier: string;
    MetricQueries: MetricQuery[];
    StartTime: Date;
    EndTime: Date;
    PeriodInSeconds?: number;
    MaxResults?: number;
    NextToken?: string;
    PeriodAlignment?: PeriodAlignment;
}
export declare const GetResourceMetricsRequest: S.Schema<GetResourceMetricsRequest>;
export interface ResponseResourceMetricKey {
    Metric: string;
    Dimensions?: {
        [key: string]: string | undefined;
    };
}
export declare const ResponseResourceMetricKey: S.Schema<ResponseResourceMetricKey>;
export interface DataPoint {
    Timestamp: Date;
    Value: number;
}
export declare const DataPoint: S.Schema<DataPoint>;
export type DataPointsList = DataPoint[];
export declare const DataPointsList: S.$Array<S.Schema<DataPoint>>;
export interface MetricKeyDataPoints {
    Key?: ResponseResourceMetricKey;
    DataPoints?: DataPoint[];
}
export declare const MetricKeyDataPoints: S.Schema<MetricKeyDataPoints>;
export type MetricKeyDataPointsList = MetricKeyDataPoints[];
export declare const MetricKeyDataPointsList: S.$Array<S.Schema<MetricKeyDataPoints>>;
export interface GetResourceMetricsResponse {
    AlignedStartTime?: Date;
    AlignedEndTime?: Date;
    Identifier?: string;
    MetricList?: MetricKeyDataPoints[];
    NextToken?: string;
}
export declare const GetResourceMetricsResponse: S.Schema<GetResourceMetricsResponse>;
export type DimensionsMetricList = string[];
export declare const DimensionsMetricList: S.$Array<S.String>;
export type FineGrainedAction = "DescribeDimensionKeys" | "GetDimensionKeyDetails" | "GetResourceMetrics" | (string & {});
export declare const FineGrainedAction: S.String;
export type AuthorizedActionsList = FineGrainedAction[];
export declare const AuthorizedActionsList: S.$Array<S.String>;
export interface ListAvailableResourceDimensionsRequest {
    ServiceType: ServiceType;
    Identifier: string;
    Metrics: string[];
    MaxResults?: number;
    NextToken?: string;
    AuthorizedActions?: FineGrainedAction[];
}
export declare const ListAvailableResourceDimensionsRequest: S.Schema<ListAvailableResourceDimensionsRequest>;
export interface DimensionDetail {
    Identifier?: string;
}
export declare const DimensionDetail: S.Schema<DimensionDetail>;
export type DimensionDetailList = DimensionDetail[];
export declare const DimensionDetailList: S.$Array<S.Schema<DimensionDetail>>;
export interface DimensionGroupDetail {
    Group?: string;
    Dimensions?: DimensionDetail[];
}
export declare const DimensionGroupDetail: S.Schema<DimensionGroupDetail>;
export type DimensionGroupDetailList = DimensionGroupDetail[];
export declare const DimensionGroupDetailList: S.$Array<S.Schema<DimensionGroupDetail>>;
export interface MetricDimensionGroups {
    Metric?: string;
    Groups?: DimensionGroupDetail[];
}
export declare const MetricDimensionGroups: S.Schema<MetricDimensionGroups>;
export type MetricDimensionsList = MetricDimensionGroups[];
export declare const MetricDimensionsList: S.$Array<S.Schema<MetricDimensionGroups>>;
export interface ListAvailableResourceDimensionsResponse {
    MetricDimensions?: MetricDimensionGroups[];
    NextToken?: string;
}
export declare const ListAvailableResourceDimensionsResponse: S.Schema<ListAvailableResourceDimensionsResponse>;
export type MetricTypeList = string[];
export declare const MetricTypeList: S.$Array<S.String>;
export interface ListAvailableResourceMetricsRequest {
    ServiceType: ServiceType;
    Identifier: string;
    MetricTypes: string[];
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListAvailableResourceMetricsRequest: S.Schema<ListAvailableResourceMetricsRequest>;
export interface ResponseResourceMetric {
    Metric?: string;
    Description?: string;
    Unit?: string;
}
export declare const ResponseResourceMetric: S.Schema<ResponseResourceMetric>;
export type ResponseResourceMetricList = ResponseResourceMetric[];
export declare const ResponseResourceMetricList: S.$Array<S.Schema<ResponseResourceMetric>>;
export interface ListAvailableResourceMetricsResponse {
    Metrics?: ResponseResourceMetric[];
    NextToken?: string;
}
export declare const ListAvailableResourceMetricsResponse: S.Schema<ListAvailableResourceMetricsResponse>;
export interface ListPerformanceAnalysisReportsRequest {
    ServiceType: ServiceType;
    Identifier: string;
    NextToken?: string;
    MaxResults?: number;
    ListTags?: boolean;
}
export declare const ListPerformanceAnalysisReportsRequest: S.Schema<ListPerformanceAnalysisReportsRequest>;
export interface AnalysisReportSummary {
    AnalysisReportId?: string;
    CreateTime?: Date;
    StartTime?: Date;
    EndTime?: Date;
    Status?: AnalysisStatus;
    Tags?: Tag[];
}
export declare const AnalysisReportSummary: S.Schema<AnalysisReportSummary>;
export type AnalysisReportSummaryList = AnalysisReportSummary[];
export declare const AnalysisReportSummaryList: S.$Array<S.Schema<AnalysisReportSummary>>;
export interface ListPerformanceAnalysisReportsResponse {
    AnalysisReports?: AnalysisReportSummary[];
    NextToken?: string;
}
export declare const ListPerformanceAnalysisReportsResponse: S.Schema<ListPerformanceAnalysisReportsResponse>;
export interface ListTagsForResourceRequest {
    ServiceType: ServiceType;
    ResourceARN: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    Tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface TagResourceRequest {
    ServiceType: ServiceType;
    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 {
    ServiceType: ServiceType;
    ResourceARN: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
declare const InternalServiceError_base: S.Class<InternalServiceError, S.TaggedStruct<"InternalServiceError", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class InternalServiceError extends InternalServiceError_base {
}
declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidArgumentException extends InvalidArgumentException_base {
}
declare const NotAuthorizedException_base: S.Class<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class NotAuthorizedException extends NotAuthorizedException_base {
}
export type CreatePerformanceAnalysisReportError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Creates a new performance analysis report for a specific time period for the
 * DB instance.
 */
export declare const createPerformanceAnalysisReport: API.OperationMethod<CreatePerformanceAnalysisReportRequest, CreatePerformanceAnalysisReportResponse, CreatePerformanceAnalysisReportError, Credentials | Region | HttpClient.HttpClient>;
export type DeletePerformanceAnalysisReportError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Deletes a performance analysis report.
 */
export declare const deletePerformanceAnalysisReport: API.OperationMethod<DeletePerformanceAnalysisReportRequest, DeletePerformanceAnalysisReportResponse, DeletePerformanceAnalysisReportError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeDimensionKeysError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * For a specific time period, retrieve the top `N` dimension keys for a metric.
 *
 * Each response element returns a maximum of 500 bytes. For larger elements, such as SQL statements,
 * only the first 500 bytes are returned.
 */
export declare const describeDimensionKeys: API.OperationMethod<DescribeDimensionKeysRequest, DescribeDimensionKeysResponse, DescribeDimensionKeysError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeDimensionKeysRequest) => stream.Stream<DescribeDimensionKeysResponse, DescribeDimensionKeysError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeDimensionKeysRequest) => stream.Stream<unknown, DescribeDimensionKeysError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetDimensionKeyDetailsError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Get the attributes of the specified dimension group for a DB instance or data source. For example, if you specify a SQL ID,
 * `GetDimensionKeyDetails` retrieves the full text of the dimension `db.sql.statement` associated with this ID.
 * This operation is useful because `GetResourceMetrics` and `DescribeDimensionKeys` don't support retrieval of large
 * SQL statement text, lock snapshots, and execution plans.
 */
export declare const getDimensionKeyDetails: API.OperationMethod<GetDimensionKeyDetailsRequest, GetDimensionKeyDetailsResponse, GetDimensionKeyDetailsError, Credentials | Region | HttpClient.HttpClient>;
export type GetPerformanceAnalysisReportError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Retrieves the report including the report ID, status, time details, and the insights
 * with recommendations. The report status can be `RUNNING`,
 * `SUCCEEDED`, or `FAILED`. The insights include the
 * `description` and `recommendation` fields.
 */
export declare const getPerformanceAnalysisReport: API.OperationMethod<GetPerformanceAnalysisReportRequest, GetPerformanceAnalysisReportResponse, GetPerformanceAnalysisReportError, Credentials | Region | HttpClient.HttpClient>;
export type GetResourceMetadataError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Retrieve the metadata for different features. For example, the metadata might indicate
 * that a feature is turned on or off on a specific DB instance.
 */
export declare const getResourceMetadata: API.OperationMethod<GetResourceMetadataRequest, GetResourceMetadataResponse, GetResourceMetadataError, Credentials | Region | HttpClient.HttpClient>;
export type GetResourceMetricsError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Retrieve Performance Insights metrics for a set of data sources over a time period. You can provide
 * specific dimension groups and dimensions, and provide filtering criteria for each group. You must specify an aggregate function for
 * each metric.
 *
 * Each response element returns a maximum of 500 bytes. For larger elements, such as SQL statements,
 * only the first 500 bytes are returned.
 */
export declare const getResourceMetrics: API.OperationMethod<GetResourceMetricsRequest, GetResourceMetricsResponse, GetResourceMetricsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetResourceMetricsRequest) => stream.Stream<GetResourceMetricsResponse, GetResourceMetricsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetResourceMetricsRequest) => stream.Stream<unknown, GetResourceMetricsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListAvailableResourceDimensionsError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Retrieve the dimensions that can be queried for each specified metric type on a specified DB instance.
 */
export declare const listAvailableResourceDimensions: API.OperationMethod<ListAvailableResourceDimensionsRequest, ListAvailableResourceDimensionsResponse, ListAvailableResourceDimensionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAvailableResourceDimensionsRequest) => stream.Stream<ListAvailableResourceDimensionsResponse, ListAvailableResourceDimensionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAvailableResourceDimensionsRequest) => stream.Stream<unknown, ListAvailableResourceDimensionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListAvailableResourceMetricsError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Retrieve metrics of the specified types that can be queried for a specified DB instance.
 */
export declare const listAvailableResourceMetrics: API.OperationMethod<ListAvailableResourceMetricsRequest, ListAvailableResourceMetricsResponse, ListAvailableResourceMetricsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAvailableResourceMetricsRequest) => stream.Stream<ListAvailableResourceMetricsResponse, ListAvailableResourceMetricsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAvailableResourceMetricsRequest) => stream.Stream<unknown, ListAvailableResourceMetricsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListPerformanceAnalysisReportsError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Lists all the analysis reports created for the DB instance. The reports are sorted based on the start time of each report.
 */
export declare const listPerformanceAnalysisReports: API.OperationMethod<ListPerformanceAnalysisReportsRequest, ListPerformanceAnalysisReportsResponse, ListPerformanceAnalysisReportsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListPerformanceAnalysisReportsRequest) => stream.Stream<ListPerformanceAnalysisReportsResponse, ListPerformanceAnalysisReportsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListPerformanceAnalysisReportsRequest) => stream.Stream<unknown, ListPerformanceAnalysisReportsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Retrieves all the metadata tags associated with Amazon RDS Performance Insights resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Adds metadata tags to the Amazon RDS Performance Insights resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InternalServiceError | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Deletes the metadata tags from the Amazon RDS Performance Insights resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=pi.d.ts.map