@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/services/codebuild/main.js

@@ -0,0 +1,67 @@
+import { Duration } from 'aws-cdk-lib';
+import { BuildSpec, ComputeType, LinuxBuildImage, Project } from 'aws-cdk-lib/aws-codebuild';
+/**
+ * @classdesc Provides operations on AWS Code Build.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.codeBuildManager.createImageForCloudfrontInvalidation('MyInvalidation', this, './docker ')
+ *   }
+ * }
+ * @see [CDK Codebuild Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild-readme.html}
+ */
+export class CodeBuildManager {
+    /**
+     *
+     * @param id
+     * @param scope
+     * @param dockerfilePath
+     */
+    createImageForCloudfrontInvalidation(id, scope, dockerfilePath) {
+        return scope.ecrManager.createDockerImage(`${id}-build-image`, scope, dockerfilePath);
+    }
+    /**
+     *
+     * @param id
+     * @param scope
+     * @param dockerFilepath
+     * @param distributionId
+     * @param paths
+     */
+    createProjectForCloudfrontInvalidation(id, scope, dockerFilepath, distributionId, paths) {
+        const invalidationPaths = paths ?? '/*';
+        return new Project(scope, `${id}-install-deps-project`, {
+            buildSpec: BuildSpec.fromObject({
+                phases: {
+                    build: {
+                        commands: [
+                            `aws cloudfront create-invalidation --distribution-id ${distributionId} --paths "${invalidationPaths}"`,
+                        ],
+                    },
+                },
+                version: '0.1',
+            }),
+            environment: {
+                buildImage: LinuxBuildImage.fromDockerRegistry(this.createImageForCloudfrontInvalidation(id, scope, dockerFilepath).imageUri),
+                computeType: ComputeType.SMALL,
+                privileged: true,
+            },
+            logging: {
+                cloudWatch: {
+                    enabled: true,
+                    logGroup: scope.logManager.createLogGroup(`${id}-project-log-group`, scope, {
+                        logGroupName: `${id}-cloudfront-invalidation`,
+                    }),
+                },
+            },
+            role: scope.iamManager.createRoleForCloudfrontInvalidation(id, scope),
+            timeout: Duration.minutes(5),
+        });
+    }
+}

package/dist/src/services/constants.d.ts

@@ -0,0 +1,4 @@
+export declare enum Architecture {
+    ARM_64 = "ARM_64",
+    X86_64 = "X86_64"
+}

package/dist/src/services/constants.js

@@ -0,0 +1,5 @@
+export var Architecture;
+(function (Architecture) {
+    Architecture["ARM_64"] = "ARM_64";
+    Architecture["X86_64"] = "X86_64";
+})(Architecture || (Architecture = {}));

package/dist/src/services/dynamodb/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/dynamodb/index.js

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/dynamodb/main.d.ts

@@ -0,0 +1,35 @@
+import { Table, TableV2 } from 'aws-cdk-lib/aws-dynamodb';
+import { CommonConstruct } from '../../common/index.js';
+import { TableProps, TablePropsV2 } from './types.js';
+/**
+ * @classdesc Provides operations on AWS DynamoDB
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.dynamodbManager.createTable('MyTable', this, tableProps)
+ *   }
+ * }
+ * @see [CDK Certificate Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html}
+ */
+export declare class DynamodbManager {
+    /**
+     * @summary Method to create a table
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props table props
+     */
+    createTable(id: string, scope: CommonConstruct, props: TableProps): Table;
+    /**
+     * @summary Method to create a table
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props table props
+     */
+    createTableV2(id: string, scope: CommonConstruct, props: TablePropsV2): TableV2;
+}

package/dist/src/services/dynamodb/main.js

@@ -0,0 +1,72 @@
+import { Tags } from 'aws-cdk-lib';
+import { BillingMode, Table, TableV2, TableEncryption } from 'aws-cdk-lib/aws-dynamodb';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS DynamoDB
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.dynamodbManager.createTable('MyTable', this, tableProps)
+ *   }
+ * }
+ * @see [CDK Certificate Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html}
+ */
+export class DynamodbManager {
+    /**
+     * @summary Method to create a table
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props table props
+     */
+    createTable(id, scope, props) {
+        if (!props)
+            throw `Table props undefined for ${id}`;
+        if (!props.tableName)
+            throw `Table tableName undefined for ${id}`;
+        const table = new Table(scope, `${id}`, {
+            ...props,
+            billingMode: props.billingMode ?? BillingMode.PAY_PER_REQUEST,
+            encryption: props.encryption ?? TableEncryption.AWS_MANAGED,
+            tableName: scope.resourceNameFormatter.format(props.tableName, scope.props.resourceNameOptions?.table),
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(table).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-tableName`, scope, table.tableName);
+        createCfnOutput(`${id}-tableArn`, scope, table.tableArn);
+        return table;
+    }
+    /**
+     * @summary Method to create a table
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props table props
+     */
+    createTableV2(id, scope, props) {
+        if (!props)
+            throw `Table props undefined for ${id}`;
+        if (!props.tableName)
+            throw `Table tableName undefined for ${id}`;
+        const table = new TableV2(scope, `${id}`, {
+            ...props,
+            tableName: scope.resourceNameFormatter.format(props.tableName, scope.props.resourceNameOptions?.table),
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(table).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-tableName`, scope, table.tableName);
+        createCfnOutput(`${id}-tableArn`, scope, table.tableArn);
+        return table;
+    }
+}

package/dist/src/services/dynamodb/types.d.ts

@@ -0,0 +1,10 @@
+import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+import { TagProps } from '../../types/index.js';
+/**
+ */
+export interface TableProps extends dynamodb.TableProps {
+    tags?: TagProps[];
+}
+export interface TablePropsV2 extends dynamodb.TablePropsV2 {
+    tags?: TagProps[];
+}

package/dist/src/services/dynamodb/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/elastic-container-registry/index.d.ts

@@ -0,0 +1 @@
+export * from './main.js';

package/dist/src/services/elastic-container-registry/index.js

@@ -0,0 +1 @@
+export * from './main.js';

package/dist/src/services/elastic-container-registry/main.d.ts

@@ -0,0 +1,27 @@
+import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';
+import { CommonConstruct } from '../../common/index.js';
+/**
+ * @classdesc Provides operations on AWS Elastic Container Registry.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.ecrManager.createDockerImage('MyImage', this, dockerfilePath)
+ *   }
+ * }
+ * @see [CDK ECR Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecr-readme.html}
+ */
+export declare class EcrManager {
+    /**
+     * @summary Method to create a docker image in ecr
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param dockerfilePath
+     */
+    createDockerImage(id: string, scope: CommonConstruct, dockerfilePath: string): DockerImageAsset;
+}

package/dist/src/services/elastic-container-registry/main.js

@@ -0,0 +1,33 @@
+import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS Elastic Container Registry.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.ecrManager.createDockerImage('MyImage', this, dockerfilePath)
+ *   }
+ * }
+ * @see [CDK ECR Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecr-readme.html}
+ */
+export class EcrManager {
+    /**
+     * @summary Method to create a docker image in ecr
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param dockerfilePath
+     */
+    createDockerImage(id, scope, dockerfilePath) {
+        const asset = new DockerImageAsset(scope, `${id}`, {
+            directory: dockerfilePath,
+        });
+        createCfnOutput(`${id}-dockerImageArn`, scope, asset.imageUri);
+        return asset;
+    }
+}

package/dist/src/services/elastic-container-service/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/elastic-container-service/index.js

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/elastic-container-service/main.d.ts

@@ -0,0 +1,56 @@
+import { IVpc } from 'aws-cdk-lib/aws-ec2';
+import { Cluster, ContainerImage, ICluster, TaskDefinition } from 'aws-cdk-lib/aws-ecs';
+import { ApplicationLoadBalancedFargateService } from 'aws-cdk-lib/aws-ecs-patterns';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { CommonConstruct } from '../../common/index.js';
+import { EcsApplicationLoadBalancedFargateServiceProps, EcsClusterProps, EcsTaskProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS Elastic Container Service.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.ecsManager.createEcsCluster('MyCluster', this, vpc)
+ *   }
+ * }
+ * @see [CDK ECS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs-readme.html}
+ */
+export declare class EcsManager {
+    /**
+     * @summary Method to create an ecs cluster
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param vpc
+     */
+    createEcsCluster(id: string, scope: CommonConstruct, props: EcsClusterProps, vpc: IVpc): Cluster;
+    /**
+     * @summary Method to create an ecs fargate task
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param role
+     * @param logGroup
+     * @param containerImage
+     * @param environment
+     * @param secrets
+     * @param command
+     */
+    createEcsFargateTask(id: string, scope: CommonConstruct, props: EcsTaskProps, cluster: ICluster, role: Role, logGroup: ILogGroup, containerImage: ContainerImage, environment?: any, secrets?: any, command?: string[]): TaskDefinition;
+    /**
+     * @summary Method to create an application load balanced ecs fargate task
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param logGroup
+     */
+    createLoadBalancedFargateService(id: string, scope: CommonConstruct, props: EcsApplicationLoadBalancedFargateServiceProps, cluster: ICluster, logGroup: ILogGroup): ApplicationLoadBalancedFargateService;
+}

package/dist/src/services/elastic-container-service/main.js

@@ -0,0 +1,149 @@
+import { Duration, Tags } from 'aws-cdk-lib';
+import { Cluster, Compatibility, CpuArchitecture, LogDriver, NetworkMode, OperatingSystemFamily, TaskDefinition, } from 'aws-cdk-lib/aws-ecs';
+import { ApplicationLoadBalancedFargateService } from 'aws-cdk-lib/aws-ecs-patterns';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS Elastic Container Service.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.ecsManager.createEcsCluster('MyCluster', this, vpc)
+ *   }
+ * }
+ * @see [CDK ECS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs-readme.html}
+ */
+export class EcsManager {
+    /**
+     * @summary Method to create an ecs cluster
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param vpc
+     */
+    createEcsCluster(id, scope, props, vpc) {
+        if (!props)
+            throw `Ecs Cluster props undefined for ${id}`;
+        const ecsCluster = new Cluster(scope, `${id}`, {
+            ...props,
+            clusterName: `${props.clusterName}-${scope.props.stage}`,
+            vpc,
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(ecsCluster).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-clusterArn`, scope, ecsCluster.clusterArn);
+        createCfnOutput(`${id}-clusterName`, scope, ecsCluster.clusterName);
+        return ecsCluster;
+    }
+    /**
+     * @summary Method to create an ecs fargate task
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param role
+     * @param logGroup
+     * @param containerImage
+     * @param environment
+     * @param secrets
+     * @param command
+     */
+    createEcsFargateTask(id, scope, props, cluster, role, logGroup, containerImage, environment, secrets, command) {
+        if (!props)
+            throw `EcsTask props undefined for ${id}`;
+        const ecsTask = new TaskDefinition(scope, `${id}`, {
+            ...props,
+            compatibility: Compatibility.FARGATE,
+            executionRole: role,
+            family: `${props.family}-${scope.props.stage}`,
+            networkMode: NetworkMode.AWS_VPC,
+            runtimePlatform: {
+                cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? CpuArchitecture.X86_64,
+                operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? OperatingSystemFamily.LINUX,
+            },
+            taskRole: role,
+        });
+        ecsTask.addContainer('EcsContainer', {
+            command,
+            cpu: props.cpu ? parseInt(props.cpu) : undefined,
+            disableNetworking: false,
+            environment,
+            image: containerImage,
+            logging: LogDriver.awsLogs({
+                logGroup,
+                logRetention: props.logging?.logRetention,
+                multilinePattern: props.logging?.multilinePattern,
+                streamPrefix: `${id}`,
+            }),
+            memoryLimitMiB: props.memoryMiB ? parseInt(props.memoryMiB) : undefined,
+            privileged: false,
+            secrets,
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(ecsTask).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-taskArn`, scope, ecsTask.taskDefinitionArn);
+        return ecsTask;
+    }
+    /**
+     * @summary Method to create an application load balanced ecs fargate task
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param logGroup
+     */
+    createLoadBalancedFargateService(id, scope, props, cluster, logGroup) {
+        if (!props)
+            throw `Ecs Load balanced Fargate Service props undefined for ${id}`;
+        if (!props.loadBalancerName)
+            throw `Ecs loadBalancerName undefined for ${id}`;
+        if (!props.serviceName)
+            throw `Ecs serviceName undefined for ${id}`;
+        if (!props.taskImageOptions)
+            throw `TaskImageOptions for Ecs Load balanced Fargate Service props undefined for ${id}`;
+        const fargateService = new ApplicationLoadBalancedFargateService(scope, `${id}-ecs-service`, {
+            ...props,
+            assignPublicIp: props.assignPublicIp ?? true,
+            cluster,
+            enableECSManagedTags: true,
+            healthCheckGracePeriod: props.healthCheckGracePeriod ?? Duration.seconds(60),
+            loadBalancerName: scope.resourceNameFormatter.format(props.loadBalancerName, scope.props.resourceNameOptions?.ecs),
+            runtimePlatform: {
+                cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? CpuArchitecture.X86_64,
+                operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? OperatingSystemFamily.LINUX,
+            },
+            serviceName: scope.resourceNameFormatter.format(props.serviceName, scope.props.resourceNameOptions?.ecs),
+            taskImageOptions: {
+                ...props.taskImageOptions,
+                enableLogging: props.taskImageOptions?.enableLogging ?? true,
+                logDriver: props.taskImageOptions?.logDriver ??
+                    LogDriver.awsLogs({
+                        logGroup: logGroup,
+                        logRetention: props.logging?.logRetention,
+                        multilinePattern: props.logging?.multilinePattern,
+                        streamPrefix: `${id}-${scope.props.stage}/ecs`,
+                    }),
+            },
+        });
+        if (props.healthCheck) {
+            fargateService.targetGroup.configureHealthCheck({
+                ...props.healthCheck,
+                interval: props.healthCheck.interval ?? Duration.seconds(props.healthCheck.intervalInSecs),
+                timeout: props.healthCheck.timeout ?? Duration.seconds(props.healthCheck.timeoutInSecs),
+            });
+        }
+        return fargateService;
+    }
+}

package/dist/src/services/elastic-container-service/types.d.ts

@@ -0,0 +1,45 @@
+import { ScalingSchedule } from 'aws-cdk-lib/aws-applicationautoscaling';
+import { AwsLogDriverProps, ClusterProps, HealthCheck as FargateHealthCheck, MountPoint, TaskDefinitionProps } from 'aws-cdk-lib/aws-ecs';
+import { ApplicationLoadBalancedFargateServiceProps } from 'aws-cdk-lib/aws-ecs-patterns';
+import { HealthCheck as ElbHealthCheck } from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { TagProps } from '../../types/index.js';
+/**
+ */
+export interface EcsClusterProps extends ClusterProps {
+    tags?: TagProps[];
+}
+/**
+ */
+export interface EcsTaskProps extends TaskDefinitionProps {
+    logging?: AwsLogDriverProps;
+    tags?: TagProps[];
+}
+export interface EcsScalingProps {
+    maxCapacity?: number;
+    minCapacity?: number;
+    scaleOnCpuUtilization?: number;
+    scaleOnMemoryUtilization?: number;
+    scaleOnRequestsPerTarget?: number;
+    scaleOnSchedule?: ScalingSchedule;
+}
+/**
+ */
+export interface HealthCheck extends ElbHealthCheck {
+    intervalInSecs: number;
+    timeoutInSecs: number;
+}
+/**
+ *
+ */
+export interface EcsApplicationLoadBalancedFargateServiceHealthCheck extends FargateHealthCheck {
+    intervalInSecs: number;
+    timeoutInSecs: number;
+}
+/**
+ */
+export interface EcsApplicationLoadBalancedFargateServiceProps extends ApplicationLoadBalancedFargateServiceProps {
+    healthCheck?: EcsApplicationLoadBalancedFargateServiceHealthCheck;
+    logging?: AwsLogDriverProps;
+    mountPoints?: MountPoint[];
+    siteScaling?: EcsScalingProps;
+}

package/dist/src/services/elastic-container-service/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/elastic-file-system/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/elastic-file-system/index.js

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/elastic-file-system/main.d.ts

@@ -0,0 +1,42 @@
+import { ISecurityGroup, IVpc, SubnetSelection } from 'aws-cdk-lib/aws-ec2';
+import { FileSystem } from 'aws-cdk-lib/aws-efs';
+import { CommonConstruct } from '../../common/index.js';
+import { EfsAccessPointOptions, EfsFileSystemProps } from './types.js';
+export declare const DEFAULT_CREATE_ACL: {
+    ownerGid: string;
+    ownerUid: string;
+    permissions: string;
+};
+export declare const DEFAULT_POSIX_USER: {
+    gid: string;
+    uid: string;
+};
+/**
+ * @classdesc Provides operations on AWS Elastic File System.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.efsManager.createFileSystem('MyFileSystem', this, fileSystemProps, vpc)
+ *   }
+ * }
+ * @see [CDK EFS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_efs-readme.html}
+ */
+export declare class EfsManager {
+    /**
+     * @summary Method to create an efs file system
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the file system props
+     * @param vpc the vpc to use for the file system
+     * @param accessPointOptions optional access point configuration options for the file system
+     * @param securityGroup optional security groups to configure for the file system
+     * @param vpcSubnets optional subnets to configure for the file system
+     */
+    createFileSystem(id: string, scope: CommonConstruct, props: EfsFileSystemProps, vpc: IVpc, accessPointOptions?: EfsAccessPointOptions[], securityGroup?: ISecurityGroup, vpcSubnets?: SubnetSelection): FileSystem;
+}