import { AWS } from "./AWS";
import { VPC } from "./VPC";
import { CUR } from "./CUR";
export declare namespace RDS {
    class Instance extends AWS.Resource {
        name: string;
        engine: string;
        engineVersion: string;
        allocatedStorage: number;
        type: string;
        status: string;
        maintenanceWindow: string;
        private _vpc;
        private _az1;
        private _az2;
        multiAz: boolean;
        private _subnets;
        private _cluster;
        private _utilization;
        private _dbConnections;
        private _readIops;
        private _writeIops;
        private _replicas;
        static isTypeOf(resource: AWS.Resource): resource is Instance;
        static new(session: AWS.Session, id?: string, name?: string, engine?: string, engineVersion?: string, allocatedStorage?: number, type?: string, status?: string, vpc?: VPC, az1?: VPC.AvailabilityZone, az2?: VPC.AvailabilityZone, multiAz?: boolean, subnets?: VPC.Subnet[], cluster?: Cluster, replicas?: Instance[], maintenanceWindow?: string): Instance;
        private constructor();
        getInstanceCosts(year: number): AWS.Resource.Costs | undefined;
        hasAllocatedStorage(): boolean;
        hasStatus(): boolean;
        hasType(): boolean;
        hasEngine(): boolean;
        hasEngineVersion(): boolean;
        hasName(): boolean;
        get replicas(): RDS.Instance[];
        protected updatePreferredParent(parents: AWS.Resource[]): AWS.Resource | undefined;
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        utilization(days: number): Promise<Instance.Metric.CPU.Utilization>;
        dbConnections(statistic: string, days: number): Promise<Instance.Metric.DatabaseConnections>;
        readIops(statistic: string, days: number): Promise<Instance.Metric.ReadIOPS>;
        writeIops(statistic: string, days: number): Promise<Instance.Metric.WriteIOPS>;
        get vpc(): VPC | null;
        hasCluster(): boolean;
        get cluster(): Cluster | null;
        hasVpc(): boolean;
        get az1(): VPC.AvailabilityZone | null;
        get az2(): VPC.AvailabilityZone | null;
        get subnets(): VPC.Subnet[];
        hasAz1(): boolean;
        hasAz2(): boolean;
    }
    namespace Instance {
        const type = "RDS.Instance";
        class Metric extends AWS.Metric {
        }
        namespace Metric {
            function create<M extends Metric>(session: AWS.Session, MetricClass: AWS.Metric.Class<M>, resource: AWS.Resource, metric: string, statistic: string, period: number, days: number): Promise<M>;
            namespace CPU {
                class Utilization extends Metric {
                    static new(session: AWS.Session, resource: AWS.Resource, days: number): Promise<Utilization>;
                }
            }
            class DatabaseConnections extends Metric {
                static new(session: AWS.Session, resource: AWS.Resource, statistic: string, days: number): Promise<DatabaseConnections>;
            }
            class ReadIOPS extends Metric {
                static new(session: AWS.Session, resource: AWS.Resource, statistic: string, days: number): Promise<DatabaseConnections>;
            }
            class WriteIOPS extends Metric {
                static new(session: AWS.Session, resource: AWS.Resource, statistic: string, days: number): Promise<DatabaseConnections>;
            }
        }
    }
    class Instances extends Array<Instance> {
        private static addInstanceToAz;
        private static describeInstances;
        static fetch(session: AWS.Session, instanceIds?: string[]): Promise<Instances>;
        static costs(account: string, curSession: AWS.Session, catalog: string, database: string, table: string, outputLocation: string, year: number): Promise<CUR.ResourceCost[]>;
    }
    class Cluster extends AWS.Resource {
        name: string;
        engine: string;
        engineVersion: string;
        allocatedStorage: number;
        type: string;
        status: string;
        private _instances;
        static new(session: AWS.Session, id?: string, name?: string, engine?: string, engineVersion?: string, allocatedStorage?: number, status?: string, instances?: Instance[]): Cluster;
        private constructor();
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        hasName(): boolean;
        hasAllocatedStorage(): boolean;
        hasStatus(): boolean;
        hasEngine(): boolean;
        hasEngineVersion(): boolean;
        get instances(): Instance[];
        hasInstances(): boolean;
    }
    namespace Cluster {
        const type = "RDS.Cluster";
    }
    class Clusters extends Array<Cluster> {
        private static describeClusters;
        static fetch(session: AWS.Session, clusterIds?: string[]): Promise<Clusters>;
    }
}