import * as ec2 from "../../aws-ec2";
import * as iam from "../../aws-iam";
import * as kms from "../../aws-kms";
import { IResource, RemovalPolicy, Resource, Size } from "../../core";
import { Construct, IDependable } from 'constructs';
import { AccessPoint, AccessPointOptions } from './access-point';
/**
 * (experimental) EFS Lifecycle Policy, if a file is not accessed for given days, it will move to EFS Infrequent Access.
 *
 * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-efs-filesystem.html#cfn-elasticfilesystem-filesystem-lifecyclepolicies
 * @experimental
 */
export declare enum LifecyclePolicy {
    /**
     * (experimental) After 7 days of not being accessed.
     *
     * @experimental
     */
    AFTER_7_DAYS = "AFTER_7_DAYS",
    /**
     * (experimental) After 14 days of not being accessed.
     *
     * @experimental
     */
    AFTER_14_DAYS = "AFTER_14_DAYS",
    /**
     * (experimental) After 30 days of not being accessed.
     *
     * @experimental
     */
    AFTER_30_DAYS = "AFTER_30_DAYS",
    /**
     * (experimental) After 60 days of not being accessed.
     *
     * @experimental
     */
    AFTER_60_DAYS = "AFTER_60_DAYS",
    /**
     * (experimental) After 90 days of not being accessed.
     *
     * @experimental
     */
    AFTER_90_DAYS = "AFTER_90_DAYS"
}
/**
 * (experimental) EFS Performance mode.
 *
 * @see https://docs.aws.amazon.com/efs/latest/ug/performance.html#performancemodes
 * @experimental
 */
export declare enum PerformanceMode {
    /**
     * (experimental) General Purpose is ideal for latency-sensitive use cases, like web serving environments, content management systems, home directories, and general file serving.
     *
     * Recommended for the majority of Amazon EFS file systems.
     *
     * @experimental
     */
    GENERAL_PURPOSE = "generalPurpose",
    /**
     * (experimental) File systems in the Max I/O mode can scale to higher levels of aggregate throughput and operations per second.
     *
     * This scaling is done with a tradeoff
     * of slightly higher latencies for file metadata operations.
     * Highly parallelized applications and workloads, such as big data analysis,
     * media processing, and genomics analysis, can benefit from this mode.
     *
     * @experimental
     */
    MAX_IO = "maxIO"
}
/**
 * (experimental) EFS Throughput mode.
 *
 * @see https://docs.aws.amazon.com/efs/latest/ug/performance.html#throughput-modes
 * @experimental
 */
export declare enum ThroughputMode {
    /**
     * (experimental) This mode on Amazon EFS scales as the size of the file system in the standard storage class grows.
     *
     * @experimental
     */
    BURSTING = "bursting",
    /**
     * (experimental) This mode can instantly provision the throughput of the file system (in MiB/s) independent of the amount of data stored.
     *
     * @experimental
     */
    PROVISIONED = "provisioned"
}
/**
 * (experimental) Represents an Amazon EFS file system.
 *
 * @experimental
 */
export interface IFileSystem extends ec2.IConnectable, IResource {
    /**
     * (experimental) The ID of the file system, assigned by Amazon EFS.
     *
     * @experimental
     * @attribute true
     */
    readonly fileSystemId: string;
    /**
     * (experimental) The ARN of the file system.
     *
     * @experimental
     * @attribute true
     */
    readonly fileSystemArn: string;
    /**
     * (experimental) Dependable that can be depended upon to ensure the mount targets of the filesystem are ready.
     *
     * @experimental
     */
    readonly mountTargetsAvailable: IDependable;
    /**
     * (experimental) Grant the actions defined in actions to the given grantee on this File System resource.
     *
     * @experimental
     */
    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
}
/**
 * (experimental) Properties of EFS FileSystem.
 *
 * @experimental
 */
export interface FileSystemProps {
    /**
     * (experimental) VPC to launch the file system in.
     *
     * @experimental
     */
    readonly vpc: ec2.IVpc;
    /**
     * (experimental) Security Group to assign to this file system.
     *
     * @default - creates new security group which allows all outbound traffic
     * @experimental
     */
    readonly securityGroup?: ec2.ISecurityGroup;
    /**
     * (experimental) Which subnets to place the mount target in the VPC.
     *
     * @default - the Vpc default strategy if not specified
     * @experimental
     */
    readonly vpcSubnets?: ec2.SubnetSelection;
    /**
     * (experimental) Defines if the data at rest in the file system is encrypted or not.
     *
     * @default - If your application has the '
     * @experimental
     * @aws-cdk /aws-efs:defaultEncryptionAtRest' feature flag set, the default is true, otherwise, the default is false.
     * @link https://docs.aws.amazon.com/cdk/latest/guide/featureflags.html
     */
    readonly encrypted?: boolean;
    /**
     * (experimental) The file system's name.
     *
     * @default - CDK generated name
     * @experimental
     */
    readonly fileSystemName?: string;
    /**
     * (experimental) The KMS key used for encryption.
     *
     * This is required to encrypt the data at rest if @encrypted is set to true.
     *
     * @default - if 'encrypted' is true, the default key for EFS (/aws/elasticfilesystem) is used
     * @experimental
     */
    readonly kmsKey?: kms.IKey;
    /**
     * (experimental) A policy used by EFS lifecycle management to transition files to the Infrequent Access (IA) storage class.
     *
     * @default - None. EFS will not transition files to the IA storage class.
     * @experimental
     */
    readonly lifecyclePolicy?: LifecyclePolicy;
    /**
     * (experimental) The performance mode that the file system will operate under.
     *
     * An Amazon EFS file system's performance mode can't be changed after the file system has been created.
     * Updating this property will replace the file system.
     *
     * @default PerformanceMode.GENERAL_PURPOSE
     * @experimental
     */
    readonly performanceMode?: PerformanceMode;
    /**
     * (experimental) Enum to mention the throughput mode of the file system.
     *
     * @default ThroughputMode.BURSTING
     * @experimental
     */
    readonly throughputMode?: ThroughputMode;
    /**
     * (experimental) Provisioned throughput for the file system.
     *
     * This is a required property if the throughput mode is set to PROVISIONED.
     * Must be at least 1MiB/s.
     *
     * @default - none, errors out
     * @experimental
     */
    readonly provisionedThroughputPerSecond?: Size;
    /**
     * (experimental) The removal policy to apply to the file system.
     *
     * @default RemovalPolicy.RETAIN
     * @experimental
     */
    readonly removalPolicy?: RemovalPolicy;
    /**
     * (experimental) Whether to enable automatic backups for the file system.
     *
     * @default false
     * @experimental
     */
    readonly enableAutomaticBackups?: boolean;
}
/**
 * (experimental) Properties that describe an existing EFS file system.
 *
 * @experimental
 */
export interface FileSystemAttributes {
    /**
     * (experimental) The security group of the file system.
     *
     * @experimental
     */
    readonly securityGroup: ec2.ISecurityGroup;
    /**
     * (experimental) The File System's ID.
     *
     * @default - determined based on fileSystemArn
     * @experimental
     */
    readonly fileSystemId?: string;
    /**
     * (experimental) The File System's Arn.
     *
     * @default - determined based on fileSystemId
     * @experimental
     */
    readonly fileSystemArn?: string;
}
declare abstract class FileSystemBase extends Resource implements IFileSystem {
    /**
     * The security groups/rules used to allow network connections to the file system.
     */
    abstract readonly connections: ec2.Connections;
    /**
    * @attribute
    */
    abstract readonly fileSystemId: string;
    /**
    * @attribute
    */
    abstract readonly fileSystemArn: string;
    /**
     * Dependable that can be depended upon to ensure the mount targets of the filesystem are ready
     */
    abstract readonly mountTargetsAvailable: IDependable;
    /**
     * (experimental) Grant the actions defined in actions to the given grantee on this File System resource.
     *
     * @param grantee Principal to grant right to.
     * @param actions The actions to grant.
     * @experimental
     */
    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
}
/**
 * (experimental) The Elastic File System implementation of IFileSystem.
 *
 * It creates a new, empty file system in Amazon Elastic File System (Amazon EFS).
 * It also creates mount target (AWS::EFS::MountTarget) implicitly to mount the
 * EFS file system on an Amazon Elastic Compute Cloud (Amazon EC2) instance or another resource.
 *
 * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-efs-filesystem.html
 * @experimental
 * @resource AWS::EFS::FileSystem
 */
export declare class FileSystem extends FileSystemBase {
    /**
     * (experimental) The default port File System listens on.
     *
     * @experimental
     */
    static readonly DEFAULT_PORT: number;
    /**
     * (experimental) Import an existing File System from the given properties.
     *
     * @experimental
     */
    static fromFileSystemAttributes(scope: Construct, id: string, attrs: FileSystemAttributes): IFileSystem;
    /**
     * (experimental) The security groups/rules used to allow network connections to the file system.
     *
     * @experimental
     */
    readonly connections: ec2.Connections;
    /**
     * (experimental) The ID of the file system, assigned by Amazon EFS.
     *
     * @experimental
     * @attribute true
     */
    readonly fileSystemId: string;
    /**
     * (experimental) The ARN of the file system.
     *
     * @experimental
     * @attribute true
     */
    readonly fileSystemArn: string;
    /**
     * (experimental) Dependable that can be depended upon to ensure the mount targets of the filesystem are ready.
     *
     * @experimental
     */
    readonly mountTargetsAvailable: IDependable;
    private readonly _mountTargetsAvailable;
    /**
     * (experimental) Constructor for creating a new EFS FileSystem.
     *
     * @experimental
     */
    constructor(scope: Construct, id: string, props: FileSystemProps);
    /**
     * (experimental) create access point from this filesystem.
     *
     * @experimental
     */
    addAccessPoint(id: string, accessPointOptions?: AccessPointOptions): AccessPoint;
}
export {};
