import { AWS } from "./AWS";
export declare namespace Lambda {
    class Func extends AWS.Resource {
        arn: string;
        memorySize: number;
        runtime: string;
        packageType: string;
        private _versions;
        private _aliases;
        private _deploymentPackage;
        layers: Func.Layer[];
        private _invocations;
        private _executionDuration;
        private _memoryConsumption;
        private _concurrency;
        private _averageCost;
        static new(session: AWS.Session, id?: string, arn?: string, memorySize?: number, runtime?: string, packageType?: string): Func;
        private constructor();
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        hasArn(): boolean;
        hasRuntime(): boolean;
        hasArmRuntime(): boolean;
        hasPackageType(): boolean;
        hasMemorySize(): boolean;
        hasLayers(): boolean;
        hasBinaries(): Promise<boolean>;
        private getVersions;
        hasVersions(): Promise<boolean>;
        versions(): Promise<string[]>;
        latestVersion(): Promise<string | undefined>;
        private getAliases;
        hasAliases(): Promise<boolean>;
        hasAliasPointingToLatestVersionOnly(): Promise<boolean>;
        aliases(): Promise<Func.Alias[]>;
        private getDeploymentPackage;
        deploymentPackage(): Promise<DeploymentPackage>;
        invocations(intervalInDays: number): Promise<Func.Metric.Invocations>;
        executionDuration(intervalInDays: number): Promise<Func.Metric.ExecutionDuration>;
        private getMemoryConsumption;
        memoryConsumption(intervalInDays: number): Promise<Func.Metric.MemoryConsumption>;
        concurrency(intervalInDays: number): Promise<Func.Metric.Concurrency>;
        averageCost(intervalInDays: number): Promise<number | undefined>;
    }
    class DeploymentPackage extends AWS.Resource {
        id: string;
        url: string;
        private _filename;
        private _extracted;
        private _parent;
        private _uuid;
        static new(session: AWS.Session, parent: Func | Func.Layer, id: string, url?: string): DeploymentPackage;
        private constructor();
        protected updateChildren(): Promise<AWS.Child.Resource[]>;
        get parent(): Func | Func.Layer;
        hasUrl(): boolean;
        filename(): Promise<string>;
        contents(): Promise<DeploymentPackage.Entry[]>;
        hasBinaries(): Promise<boolean>;
    }
    namespace DeploymentPackage {
        abstract class Entry {
            name: string;
            size: number;
            attributes: number;
            constructor(name: string, size: number, attributes: number);
            isDirectory(): this is Directory;
            isFile(): this is File;
        }
        class File extends Entry {
        }
        class Directory extends Entry {
        }
        const type = "Lambda.DeploymentPackage";
    }
    namespace Func {
        const type = "Lambda.Func";
        class Layer extends AWS.Resource {
            arn: string;
            private _deploymentPackage;
            private _func;
            static new(session: AWS.Session, func: Lambda.Func, arn?: string): Layer;
            private constructor();
            get func(): Func;
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
            hasArn(): boolean;
            private getDeploymentPackage;
            deploymentPackage(): Promise<DeploymentPackage>;
        }
        namespace Layer {
            const type = "Lambda.Func.Layer";
        }
        class Alias extends AWS.Resource {
            arn: string;
            version1: string;
            version2: string;
            weight: number;
            private _func;
            static new(session: AWS.Session, func: Func, name?: string, arn?: string, version1?: string, version2?: string, weight?: number): Alias;
            private constructor();
            protected updateChildren(): Promise<AWS.Child.Resource[]>;
            get func(): Func;
            hasName(): boolean;
            hasArn(): boolean;
            hasVersion1(): boolean;
            hasVersion2(): boolean;
            hasWeight(): boolean;
            pointsToLatestVersionOnly(): Promise<boolean>;
        }
        namespace Alias {
            const type = "Lambda.Func.Alias";
        }
        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>;
            class ExecutionDuration extends Metric {
                static new(session: AWS.Session, resource: AWS.Resource, days: number): Promise<ExecutionDuration>;
            }
            class Concurrency extends Metric {
                static new(session: AWS.Session, resource: AWS.Resource, days: number): Promise<Concurrency>;
            }
            class Invocations extends Metric {
                static new(session: AWS.Session, resource: AWS.Resource, days: number): Promise<Invocations>;
            }
            class MemoryConsumption extends Metric {
            }
        }
    }
    class Funcs extends Array<Func> {
        private static describeFunctions;
        static fetch(session: AWS.Session): Promise<Funcs>;
    }
}