import * as SDK from 'aws-sdk';
import { AWS } from "./AWS";
import { EC2 } from "./EC2";
import { VPC } from "./VPC";
import { CUR } from "./CUR";
export declare namespace ELB {
    class TargetGroup extends AWS.Resource {
        type: TargetGroup.Type;
        private _targets;
        static isTypeOf(resource: AWS.Resource): resource is TargetGroup;
        static new(session: AWS.Session, name?: string, type?: TargetGroup.Type): TargetGroup;
        private constructor();
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        hasType(): boolean;
    }
    namespace TargetGroup {
        type Type = "instance" | "ip" | "lambda" | "";
        const type: AWS.Resource.Kind;
    }
    class LoadBalancer extends AWS.Resource {
        scheme: string;
        dnsName: string;
        hostedZone: string;
        zones: LoadBalancer.Zone[];
        securityGroups: string[];
        type: LoadBalancer.Type;
        private _vpc;
        protected _listeners: LoadBalancer.Listener[] | undefined;
        static isTypeOf(resource: AWS.Resource): resource is LoadBalancer;
        static new(session: AWS.Session, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: LoadBalancer.Zone[], securityGroups?: string[], vpc?: VPC): LoadBalancer;
        protected constructor(session: AWS.Session, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: LoadBalancer.Zone[], securityGroups?: string[], vpc?: VPC, type?: LoadBalancer.Type);
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        isClassic(): this is ClassicLoadBalancer;
        isApplication(): this is ApplicationLoadBalancer;
        isNetwork(): this is NetworkLoadBalancer;
        hasDnsName(): boolean;
        hasScheme(): boolean;
        hasHostedZone(): boolean;
        hasZones(): boolean;
        hasSecurityGroups(): boolean;
        setListeners(listeners: LoadBalancer.Listener[]): void;
        hasListeners(): Promise<boolean>;
        listeners: () => Promise<LoadBalancer.Listener[]>;
        get vpc(): VPC | undefined;
        hasType(): boolean;
        getSubnet(az: string): string | undefined;
        hasCompatibleZonesWith(that: LoadBalancer): boolean;
        hasDisjointListenersWith(that: LoadBalancer): Promise<boolean>;
        create(): Promise<void>;
    }
    namespace LoadBalancer {
        const type = "ELB.LoadBalancer";
        type Type = "Classic" | "Application" | "Network" | "Gateway" | "";
        class Zone {
            az: string;
            subnet: string;
            constructor(az?: string, subnet?: string);
            hasAZ(): boolean;
            hasSubnet(): boolean;
        }
        abstract class Listener extends AWS.Resource {
            protocol: Listener.Protocol;
            port: number;
            certificates: Array<string>;
            loadBalancer: LoadBalancer;
            protected constructor(session: AWS.Session, loadBalancer: LoadBalancer, protocol?: LoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>);
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
            hasCertificates(): boolean;
        }
        namespace Listener {
            const type = "ELB.LoadBalancer.Listener";
        }
        namespace Listener {
            type Protocol = ApplicationLoadBalancer.Listener.Protocol | NetworkLoadBalancer.Listener.Protocol | ClassicLoadBalancer.Listener.Protocol | "";
        }
    }
    class ClassicLoadBalancer extends LoadBalancer {
        status: string;
        type: "Classic";
        protected _listeners: ClassicLoadBalancer.Listener[];
        private _instances;
        static new(session: AWS.Session, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: LoadBalancer.Zone[], securityGroups?: string[], vpc?: VPC, instances?: EC2.Instance[]): ClassicLoadBalancer;
        protected constructor(session: AWS.Session, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: LoadBalancer.Zone[], securityGroups?: string[], vpc?: VPC, instances?: EC2.Instance[]);
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        hasInstances(): boolean;
        listeners: () => Promise<ClassicLoadBalancer.Listener[]>;
        hasOSI7Listeners(): Promise<boolean>;
        hasOSI4Listeners(): Promise<boolean>;
        isEC2Classic(): boolean;
        create(): Promise<void>;
    }
    abstract class ModernLoadBalancer extends LoadBalancer {
        arn: string;
        status: string;
        protected _listeners: Array<ModernLoadBalancer.Listener> | undefined;
        private _attributes;
        private _targetGroups;
        type: "Application" | "Network" | "Gateway";
        protected constructor(session: AWS.Session, arn?: string, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: Array<LoadBalancer.Zone>, securityGroups?: Array<string>, vpc?: VPC, status?: string, type?: LoadBalancer.Type);
        hasArn(): boolean;
        hasStatus(): boolean;
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        abstract supports(protocol: string): protocol is ModernLoadBalancer.Listener.Protocol;
        protected abstract getListeners(elb2: SDK.ELBv2): Promise<Array<ModernLoadBalancer.Listener>>;
        listeners: <T extends ModernLoadBalancer.Listener>() => Promise<T[]>;
        private getAttributes;
        attributes: () => Promise<ModernLoadBalancer.Attributes>;
        private getTargetGroups;
        targetGroups: () => Promise<TargetGroup[]>;
        protected abstract createListeners(elb2: SDK.ELBv2, arn: string): Promise<void>;
        create(): Promise<void>;
    }
    namespace ModernLoadBalancer {
        type Attributes = {
            [key: string]: string;
        };
        abstract class Listener extends LoadBalancer.Listener {
            protocol: Listener.Protocol;
            sslPolicy: string;
            defaultRule: ModernLoadBalancer.Listener.Rule | null;
            loadBalancer: ModernLoadBalancer;
            protected constructor(session: AWS.Session, loadBalancer: ModernLoadBalancer, protocol?: LoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>, sslPolicy?: string, defaultRule?: ModernLoadBalancer.Listener.Rule);
            hasSslPolicy(): boolean;
        }
        namespace Listener {
            type Protocol = ApplicationLoadBalancer.Listener.Protocol | NetworkLoadBalancer.Listener.Protocol;
            type Action = NetworkLoadBalancer.Listener.ForwardAction;
            abstract class Rule {
                actions: Array<Action>;
                constructor(actions?: Array<Action>);
                hasActions(): boolean;
            }
        }
    }
    class ApplicationLoadBalancer extends ModernLoadBalancer {
        type: "Application";
        protected _listeners: Array<ApplicationLoadBalancer.Listener> | undefined;
        static new(session: AWS.Session, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: Array<LoadBalancer.Zone>, securityGroups?: Array<string>, vpc?: VPC, arn?: string, status?: string): ApplicationLoadBalancer;
        private constructor();
        supports(protocol: string): protocol is ApplicationLoadBalancer.Listener.Protocol;
        private _getListeners;
        protected getListeners(elb2: SDK.ELBv2): Promise<Array<ApplicationLoadBalancer.Listener>>;
        protected createListeners(elb2: SDK.ELBv2, arn: string): Promise<void>;
    }
    class NetworkLoadBalancer extends ModernLoadBalancer {
        type: "Network";
        protected _listeners: Array<NetworkLoadBalancer.Listener> | undefined;
        static new(session: AWS.Session, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: Array<LoadBalancer.Zone>, securityGroups?: Array<string>, vpc?: VPC, arn?: string, status?: string): NetworkLoadBalancer;
        protected constructor(session: AWS.Session, arn?: string, name?: string, dnsName?: string, scheme?: string, hostedZone?: string, zones?: Array<LoadBalancer.Zone>, securityGroups?: Array<string>, vpc?: VPC, status?: string);
        supports(protocol: string): protocol is NetworkLoadBalancer.Listener.Protocol;
        private _getListeners;
        protected getListeners(elb2: SDK.ELBv2): Promise<Array<NetworkLoadBalancer.Listener>>;
        protected createListeners(elb2: SDK.ELBv2, arn: string): Promise<void>;
    }
    namespace ClassicLoadBalancer {
        class Listener extends LoadBalancer.Listener {
            protocol: ClassicLoadBalancer.Listener.Protocol;
            destinationProtocol: ClassicLoadBalancer.Listener.Protocol;
            destinationPort: number;
            loadBalancer: ClassicLoadBalancer;
            static new(session: AWS.Session, loadBalancer: ClassicLoadBalancer, protocol?: LoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>, destinationProtocol?: ClassicLoadBalancer.Listener.Protocol, destinationPort?: number): ClassicLoadBalancer.Listener;
            protected constructor(session: AWS.Session, loadBalancer: ClassicLoadBalancer, protocol?: LoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>, destinationProtocol?: ClassicLoadBalancer.Listener.Protocol, destinationPort?: number);
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
            hasDestinationProtocol(): boolean;
            hasDestinationPort(): boolean;
            isOSI7(): boolean;
            isOSI4(): boolean;
        }
        namespace Listener {
            type Protocol = "HTTP" | "HTTPS" | "TCP" | "SSL" | "";
        }
    }
    namespace NetworkLoadBalancer {
        class Listener extends ModernLoadBalancer.Listener {
            protocol: NetworkLoadBalancer.Listener.Protocol;
            defaultRule: NetworkLoadBalancer.Listener.Rule | null;
            alpnPolicy: Array<string>;
            loadBalancer: NetworkLoadBalancer;
            static new(session: AWS.Session, loadBalancer: NetworkLoadBalancer, protocol?: LoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>, sslPolicy?: string, defaultRule?: NetworkLoadBalancer.Listener.Rule, alpnPolicy?: Array<string>): NetworkLoadBalancer.Listener;
            protected constructor(session: AWS.Session, loadBalancer: NetworkLoadBalancer, protocol?: LoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>, sslPolicy?: string, defaultRule?: NetworkLoadBalancer.Listener.Rule, alpnPolicy?: Array<string>);
            hasAlpnPolicy(): boolean;
        }
        namespace Listener {
            type Protocol = "TCP" | "TLS" | "UDP" | "TCP_UDP";
            function isProtocol(protocol: string): protocol is Protocol;
            class Rule extends ModernLoadBalancer.Listener.Rule {
                actions: Array<NetworkLoadBalancer.Listener.ForwardAction>;
                constructor(actions: Array<NetworkLoadBalancer.Listener.ForwardAction>);
            }
            class ForwardAction {
                targetGroup: string;
                stickiness: boolean;
                stickinessDuration: number;
                constructor(targetGroup: string, stickiness?: boolean, stickinessDuration?: number);
                hasStickinessDuration(): boolean;
            }
        }
    }
    namespace ApplicationLoadBalancer {
        class Listener extends ModernLoadBalancer.Listener {
            static new(session: AWS.Session, loadBalancer: ApplicationLoadBalancer, protocol?: ApplicationLoadBalancer.Listener.Protocol, port?: number, certificates?: Array<string>, sslPolicy?: string, defaultRule?: ApplicationLoadBalancer.Listener.Rule, alpnPolicy?: Array<string>): ApplicationLoadBalancer.Listener;
        }
        namespace Listener {
            type Protocol = "HTTP" | "HTTPS";
            function isProtocol(protocol: string): protocol is Protocol;
            class Rule extends ModernLoadBalancer.Listener.Rule {
            }
        }
    }
    class LoadBalancers extends Array<LoadBalancer> {
        static describeClassicLoadBalancers(session: AWS.Session, loadBalancers?: ClassicLoadBalancer[], token?: string): Promise<ClassicLoadBalancer[]>;
        static describeLoadBalancers(session: AWS.Session, loadBalancers?: LoadBalancer[], token?: string, maxResults?: number): Promise<LoadBalancer[]>;
        static fetch(session: AWS.Session): Promise<LoadBalancers>;
        static costs(account: string, curSession: AWS.Session, catalog: string, database: string, table: string, outputLocation: string, year: number): Promise<CUR.ResourceCost[]>;
    }
    namespace Consolidation {
        type Resource = {
            vpc?: string;
            az?: string;
            subnet?: string;
            id: string;
        };
        namespace ClassicLoadBalancer {
            function getResources(session: AWS.Session, instanceIds: Array<string>): Promise<Array<Resource>>;
        }
    }
}