import { AWS } from "./AWS";
import * as K8s from "@kubernetes/client-node";
import { EC2 } from "./EC2";
import { CUR } from "./CUR";
export declare namespace EKS {
    class Cluster extends AWS.Resource {
        session: AWS.RemoteSession;
        private _namespaces;
        private _nodes;
        private _k8sClient;
        private _kubeConfig;
        private _mutex;
        static isTypeOf(resource: AWS.Resource): resource is Cluster;
        static new(session: AWS.Session, id?: string): Cluster;
        private constructor();
        private k8sClient;
        private get kubeConfigFilename();
        private loadKubeConfig;
        kubectl(args: string): Promise<string>;
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        nodes(): Promise<Cluster.Node[]>;
        namespaces(): Promise<Cluster.Namespace[]>;
        pods(): Promise<Cluster.Namespace.Pod[]>;
    }
    namespace Cluster {
        const type = "EKS.Cluster";
        abstract class Resource extends AWS.Resource {
            protected _k8sClient: K8s.CoreV1Api;
            name: string;
            protected constructor(session: AWS.Session, kind: AWS.Resource.Kind, k8sClient: K8s.CoreV1Api, id: Resource.Id);
        }
        namespace Resource {
            namespace CPU {
                class Measure {
                    private _value;
                    constructor(value?: string);
                    get value(): number | undefined;
                }
            }
            namespace Memory {
                class Measure {
                    private _value;
                    constructor(value?: string);
                    get value(): number | undefined;
                }
            }
            class Id {
                parentId: string;
                name: string;
                constructor(parentId: string, name: string);
                toString(): string;
            }
        }
        class Node extends AWS.Child.Resource {
            resource: EC2.Instance;
            attributes: Node.Attributes;
            private _cluster;
            constructor(resource: EC2.Instance, cluster: Cluster, name: string | undefined, cpu: Resource.CPU.Measure, memory: Resource.Memory.Measure);
            get cluster(): Cluster;
            pods(): Promise<Cluster.Namespace.Pod[]>;
            actualCpuUtilization(): Promise<number | undefined>;
            requestedCpuUtilization(): Promise<number | undefined>;
            actualMemoryUtilization(): Promise<number | undefined>;
            requestedMemoryUtilization(): Promise<number | undefined>;
        }
        namespace Node {
            type Attributes = {
                name: string;
                cpu: number;
                memory: number;
            };
        }
        class Namespace extends Resource {
            private _pods;
            private _cluster;
            private _mutex;
            static isTypeOf(resource: AWS.Resource): resource is Namespace;
            static new(session: AWS.Session, k8sClient: K8s.CoreV1Api, name: string, cluster: Cluster): Cluster.Namespace;
            private constructor();
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
            get cluster(): Cluster;
            private podMetrics;
            pods(): Promise<Namespace.Pod[]>;
        }
        namespace Namespace {
            const type = "EKS.Cluster.Namespace";
            class Pod extends Resource {
                status: Pod.Status;
                priority: number;
                preemptionPolicy: string;
                private _node;
                private _namespace;
                private _cpuUse;
                private _memoryUse;
                private _cpuRequested;
                private _memoryRequested;
                static isTypeOf(resource: AWS.Resource): resource is Pod;
                static new(session: AWS.Session, k8sClient: K8s.CoreV1Api, name: string, namespace: Cluster.Namespace, nodeName: string | undefined, status: Pod.Status | undefined, priority: number | undefined, preemptionPolicy: string | undefined, cpuUse: Resource.CPU.Measure, memoryUse: Resource.Memory.Measure, cpuRequested: Resource.CPU.Measure, memoryRequested: Resource.Memory.Measure): Promise<Pod>;
                private constructor();
                hasPreemptionPolicy(): boolean;
                get cpuUse(): number | undefined;
                get cpuRequested(): number | undefined;
                get memoryUse(): number | undefined;
                get memoryRequested(): number | undefined;
                get node(): Cluster.Node | undefined;
                get namespace(): Cluster.Namespace;
                protected updateChildren(): Promise<AWS.Child.Resource[]>;
            }
            namespace Pod {
                const type = "EKS.Cluster.Namespace.Pod";
                type Status = "Pending" | "Running" | "Succeeded" | "Failed" | "Unknown";
                type Metric = {
                    name: string;
                    cpu: string;
                    memory: string;
                };
            }
        }
    }
    class Clusters extends Array<Cluster> {
        private static describeClusters;
        static fetch(session: AWS.Session): Promise<Clusters>;
        static costs(account: string, curSession: AWS.Session, catalog: string, database: string, table: string, outputLocation: string, year: number): Promise<CUR.ResourceCost[]>;
    }
}