import * as SDK from 'aws-sdk';
import { AWS } from "./AWS";
import { VPC } from "./VPC";
import { EBS } from "./EBS";
import { CUR } from "./CUR";
export declare namespace EC2 {
    type Platform = "Windows" | "Linux";
    class Instance extends AWS.Resource {
        lifecycle: string;
        arn: string;
        private _az;
        private _subnet;
        state: string;
        type: string;
        platform: Platform;
        publicDNSName: string;
        publicIP: string;
        private _vpc;
        rootDeviceType: string;
        rootDeviceName: string;
        hypervisor: string;
        amiId: string;
        private _gpus;
        private _deviceAttrs;
        private _devices;
        private _cpuUtilization;
        private _memoryUtilization;
        private _inventoryEntries;
        private static _sshKey;
        static getSshKey(): Promise<string>;
        static isTypeOf(resource: AWS.Resource): resource is Instance;
        static new(session: AWS.Session, id?: string, az?: VPC.AvailabilityZone, subnet?: VPC.Subnet, state?: string, lifecycle?: string, type?: string, hypervisor?: string, platform?: string, amiId?: string, vpc?: VPC, publicDNSName?: string, publicIP?: string, rootDeviceName?: string, rootDeviceType?: string, devices?: {
            volumeId: string;
            attrs: Instance.Device.Attributes;
        }[], tags?: AWS.Tag[]): Instance;
        private constructor();
        private setSshKey;
        run(command: string): Promise<string>;
        protected updatePreferredParent(parents: AWS.Resource[]): AWS.Resource | undefined;
        devices(): Promise<Instance.Device[]>;
        get az(): VPC.AvailabilityZone | undefined;
        get vpc(): VPC | undefined;
        get subnet(): VPC.Subnet | undefined;
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        isProd(): boolean;
        hasState(): boolean;
        hasPublicDNSName(): boolean;
        hasAmiId(): boolean;
        hasPublicIP(): boolean;
        hasHypervisor(): boolean;
        isNitro(): boolean;
        hasAZ(): boolean;
        hasSubnet(): boolean;
        hasType(): boolean;
        hasVPC(): boolean;
        hasRootDeviceType(): boolean;
        hasRootDeviceName(): boolean;
        hasLifecycle(): boolean;
        private getGpus;
        hasGpus(): Promise<boolean>;
        gpus(): Promise<EC2.Instance.GPU[]>;
        deletesAllVolumesOnTermination(): boolean;
        onlyHasRootDevice(): boolean;
        getDeviceName(volumeId: string): string | undefined;
        get rootVolumeId(): string | undefined;
        isSpot(): boolean;
        isWindows(): boolean;
        getDataTransferCosts(year: number): AWS.Resource.Costs | undefined;
        getEc2Costs(year: number): AWS.Resource.Costs | undefined;
        yearlyPriceListCost(): Promise<number | undefined>;
        cpuUtilization(days: number): Promise<Instance.Metric.CPU.Utilization>;
        memoryUtilization(days: number): Promise<Instance.Metric.Memory.Utilization>;
        private getInventoryEntries;
        hasInventoryEntries(type: string): Promise<boolean>;
        inventoryEntries(type: string): Promise<SSM.InventoryEntry[]>;
    }
    namespace Instance {
        const type = "EC2.Instance";
        class Device extends AWS.Child.Resource {
            resource: EBS.Volume;
            constructor(volume: EBS.Volume, name?: string, deleteOnTermination?: boolean);
        }
        namespace Device {
            type Attributes = {
                name?: string;
                deleteOnTermination?: boolean;
            };
        }
        class GPU extends AWS.Resource {
            instance: EC2.Instance;
            static new(session: AWS.Session, instance: EC2.Instance, id?: string): GPU;
            private constructor();
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
        }
        namespace GPU {
            const type = "EC2.Instance.GPU";
        }
        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, namespace?: string): Promise<M>;
            namespace Memory {
                class Utilization extends Metric {
                    static new(session: AWS.Session, resource: AWS.Resource, days: number): Promise<Utilization>;
                }
            }
            namespace CPU {
                class Utilization extends AWS.Metric {
                    static new(session: AWS.Session, resource: AWS.Resource, days: number): Promise<Utilization>;
                    isUnderUtilized(threshold: number): boolean;
                }
            }
        }
    }
    class Instances extends Array<EC2.Instance> {
        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 AutoScalingGroup extends AWS.Resource {
        loadBalancers: string[];
        maxSize: number;
        minSize: number;
        newInstancesProtectedFromScaleIn: boolean;
        warmPoolSize: number;
        instances: AutoScalingGroup.Instance[];
        static isTypeOf(resource: AWS.Resource): resource is AutoScalingGroup;
        static new(session: AWS.Session, id?: string, loadBalancers?: string[], maxSize?: number, minSize?: number, newInstancesProtectedFromScaleIn?: boolean, warmPoolSize?: number, instances?: AutoScalingGroup.Instance[]): AutoScalingGroup;
        private constructor();
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        hasInstances(): boolean;
        hasMaxSize(): boolean;
        hasMinSize(): boolean;
        hasWarmPoolSize(): boolean;
        deletesAllVolumesOnTermination(): boolean;
        onlyHasRootDevice(): boolean;
        isSpot(): boolean;
        isWindows(): boolean;
        hasGpus(): Promise<boolean>;
    }
    namespace AutoScalingGroup {
        const type = "EC2.AutoScalingGroup";
        class Instance extends AWS.Child.Resource {
            resource: EC2.Instance;
            constructor(instance: EC2.Instance, lifecycleState?: string);
        }
    }
    class AutoScalingGroups extends Array<AutoScalingGroup> {
        private static describeGroups;
        static fetch(session: AWS.Session): Promise<AutoScalingGroups>;
    }
    namespace SSM {
        class InventoryEntry extends AWS.Resource {
            content: InventoryEntry.Content;
            static new(session: AWS.Session, id?: string, content?: InventoryEntry.Content): InventoryEntry;
            private constructor();
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
            hasContent(): boolean;
        }
        namespace InventoryEntry {
            const type = "SSM.InventoryEntry";
            type Content = {
                [key: string]: {
                    [key: string]: string;
                }[];
            };
            function contentFromInventoryResultItemMap(inventoryResultMap: SDK.SSM.Types.InventoryResultItemMap): Content;
        }
        class InventoryEntries extends Array<InventoryEntry> {
            private static getEntries;
            static fetch(session: AWS.Session): Promise<InventoryEntries>;
        }
    }
}