@digitraffic/common 2023.12.15-1 → 2024.1.19-1

package/dist/aws/infra/sqs-queue.js

@@ -1,29 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DigitrafficDLQueue = exports.DigitrafficSqsQueue = void 0;
-const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const aws_s3_1 = require("aws-cdk-lib/aws-s3");
-const aws_iam_1 = require("aws-cdk-lib/aws-iam");
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_logs_1 = require("aws-cdk-lib/aws-logs");
-const aws_lambda_event_sources_1 = require("aws-cdk-lib/aws-lambda-event-sources");
-const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
-const aws_cloudwatch_actions_1 = require("aws-cdk-lib/aws-cloudwatch-actions");
-const monitoredfunction_1 = require("./stack/monitoredfunction");
+import { Queue, QueueEncryption } from "aws-cdk-lib/aws-sqs";
+import { Duration } from "aws-cdk-lib";
+import { BlockPublicAccess, Bucket } from "aws-cdk-lib/aws-s3";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { InlineCode, Runtime } from "aws-cdk-lib/aws-lambda";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
+import { ComparisonOperator, TreatMissingData } from "aws-cdk-lib/aws-cloudwatch";
+import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
+import { Upload } from "@aws-sdk/lib-storage";
+import { MonitoredFunction } from "./stack/monitoredfunction.js";
 /**
  * Construct for creating SQS-queues.
  *
  * If you don't config your own deadLetterQueue, this will create a dlq for you, also a lambda function, a s3 bucket
  * and an alarm for the queue.  Anything that goes to the dlq will be written into the bucket and the alarm is activated.
  */
-class DigitrafficSqsQueue extends aws_sqs_1.Queue {
+export class DigitrafficSqsQueue extends Queue {
     static create(stack, name, props) {
         const queueName = `${stack.configuration.shortName}-${name}-Queue`;
         const queueProps = {
             ...props,
             ...{
-                encryption: aws_sqs_1.QueueEncryption.KMS_MANAGED,
+                encryption: QueueEncryption.KMS_MANAGED,
                 queueName,
                 deadLetterQueue: props.deadLetterQueue ?? {
                     maxReceiveCount: 2,
@@ -34,85 +32,86 @@ class DigitrafficSqsQueue extends aws_sqs_1.Queue {
         return new DigitrafficSqsQueue(stack, queueName, queueProps);
     }
 }
-exports.DigitrafficSqsQueue = DigitrafficSqsQueue;
-class DigitrafficDLQueue {
+export class DigitrafficDLQueue {
     static create(stack, name) {
         const dlqName = `${stack.configuration.shortName}-${name}-DLQ`;
         const dlq = new DigitrafficSqsQueue(stack, dlqName, {
             queueName: dlqName,
-            visibilityTimeout: aws_cdk_lib_1.Duration.seconds(60),
-            encryption: aws_sqs_1.QueueEncryption.KMS_MANAGED,
+            visibilityTimeout: Duration.seconds(60),
+            encryption: QueueEncryption.KMS_MANAGED,
         });
-        const dlqBucket = new aws_s3_1.Bucket(stack, `${dlqName}-Bucket`, {
-            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+        const dlqBucket = new Bucket(stack, `${dlqName}-Bucket`, {
+            blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
         });
         const dlqFunctionName = `${dlqName}-Function`;
-        const lambda = monitoredfunction_1.MonitoredFunction.create(stack, dlqFunctionName, {
-            runtime: aws_lambda_1.Runtime.NODEJS_16_X,
-            logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        const lambda = MonitoredFunction.create(stack, dlqFunctionName, {
+            runtime: Runtime.NODEJS_20_X,
+            logRetention: RetentionDays.ONE_YEAR,
             functionName: dlqFunctionName,
             code: getDlqCode(dlqBucket.bucketName),
-            timeout: aws_cdk_lib_1.Duration.seconds(10),
+            timeout: Duration.seconds(10),
             handler: "index.handler",
             memorySize: 128,
             reservedConcurrentExecutions: 1,
         });
-        const statement = new aws_iam_1.PolicyStatement();
+        const statement = new PolicyStatement();
         statement.addActions("s3:PutObject");
         statement.addActions("s3:PutObjectAcl");
         statement.addResources(dlqBucket.bucketArn + "/*");
         lambda.addToRolePolicy(statement);
-        lambda.addEventSource(new aws_lambda_event_sources_1.SqsEventSource(dlq));
+        lambda.addEventSource(new SqsEventSource(dlq));
         addDLQAlarm(stack, dlqName, dlq);
         return dlq;
     }
 }
-exports.DigitrafficDLQueue = DigitrafficDLQueue;
 function addDLQAlarm(stack, dlqName, dlq) {
     const alarmName = `${dlqName}-Alarm`;
     dlq.metricNumberOfMessagesReceived({
-        period: aws_cdk_lib_1.Duration.minutes(5),
+        period: Duration.minutes(5),
     })
         .createAlarm(stack, alarmName, {
         alarmName,
         threshold: 0,
         evaluationPeriods: 1,
-        treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
-        comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+        treatMissingData: TreatMissingData.NOT_BREACHING,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,
     })
-        .addAlarmAction(new aws_cloudwatch_actions_1.SnsAction(stack.warningTopic));
+        .addAlarmAction(new SnsAction(stack.warningTopic));
 }
-function getDlqCode(bName) {
-    const functionBody = DLQ_LAMBDA_CODE.replace("__bucketName__", bName)
+function getDlqCode(Bucket) {
+    const functionBody = DLQ_LAMBDA_CODE.replace("__bucketName__", Bucket)
         .replace("__upload__", uploadToS3.toString())
         .replace("__doUpload__", doUpload.toString())
         .replace("__handler__", createHandler().toString().substring(23)); // remove function handler() from signature
-    return new aws_lambda_1.InlineCode(functionBody);
+    return new InlineCode(functionBody);
 }
-async function uploadToS3(s3, bName, body, objectName) {
+async function uploadToS3(s3, Bucket, Body, Key) {
     try {
-        console.info("writing %s to %s", objectName, bName);
-        await doUpload(s3, bName, body, objectName);
+        console.info("writing %s to %s", Key, Bucket);
+        await doUpload(s3, Bucket, Body, Key);
     }
     catch (error) {
         console.warn(error);
-        console.warn("method=uploadToS3 retrying upload to bucket %s", bName);
+        console.warn("method=uploadToS3 retrying upload to bucket %s", Bucket);
         try {
-            await doUpload(s3, bName, body, objectName);
+            await doUpload(s3, Bucket, Body, Key);
         }
         catch (e2) {
-            console.error("method=uploadToS3 failed retrying upload to bucket %s", bName);
+            console.error("method=uploadToS3 failed retrying upload to bucket %s", Bucket);
         }
     }
 }
-function doUpload(s3, bName, Body, Key) {
-    return s3
-        .upload({
-        Bucket: bName,
-        Body,
-        Key,
-    })
-        .promise();
+async function doUpload(s3, Bucket, Body, Key) {
+    try {
+        const upload = new Upload({
+            client: s3,
+            params: { Bucket, Key, Body },
+        });
+        await upload.done();
+    }
+    catch (error) {
+        console.error(error);
+    }
 }
 // bucketName is unused, will be overridden in the actual lambda code below
 const bucketName = "";
@@ -126,7 +125,9 @@ function createHandler() {
         new AWS.S3(), bucketName, e.body, `dlq-${millis}-${idx}.json`)));
     };
 }
-const DLQ_LAMBDA_CODE = `const AWS = require('aws-sdk');
+const DLQ_LAMBDA_CODE = `
+import { S3, S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
 const bucketName = "__bucketName__";
 
 __upload__

package/dist/aws/infra/stack/lambda-configs.d.ts

@@ -1,8 +1,8 @@
 import { Architecture, Code, FunctionProps, Runtime } from "aws-cdk-lib/aws-lambda";
 import { IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
 import { Role } from "aws-cdk-lib/aws-iam";
-import { DigitrafficStack } from "./stack";
-import { MonitoredFunctionAlarmProps } from "./monitoredfunction";
+import { DigitrafficStack } from "./stack.js";
+import { MonitoredFunctionAlarmProps } from "./monitoredfunction.js";
 export type LambdaEnvironment = Record<string, string>;
 export type DBLambdaEnvironment = LambdaEnvironment & {
     SECRET_ID?: string;

package/dist/aws/infra/stack/lambda-configs.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultLambdaConfiguration = exports.lambdaFunctionProps = exports.databaseFunctionProps = void 0;
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const aws_logs_1 = require("aws-cdk-lib/aws-logs");
-function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
+import { Architecture, AssetCode, Runtime, } from "aws-cdk-lib/aws-lambda";
+import { Duration } from "aws-cdk-lib";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+export function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
     const vpcSubnets = stack.vpc
         ? {
             subnets: stack.vpc.privateSubnets,
@@ -19,41 +16,39 @@ function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName,
         },
     };
 }
-exports.databaseFunctionProps = databaseFunctionProps;
-function lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
+export function lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
     return {
-        runtime: config?.runtime ?? aws_lambda_1.Runtime.NODEJS_16_X,
-        architecture: config?.architecture ?? aws_lambda_1.Architecture.ARM_64,
+        runtime: config?.runtime ?? Runtime.NODEJS_20_X,
+        architecture: config?.architecture ?? Architecture.ARM_64,
         memorySize: config?.memorySize ?? 128,
         functionName: lambdaName,
         role: config?.role,
-        timeout: aws_cdk_lib_1.Duration.seconds(config?.timeout ?? 60),
-        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        timeout: Duration.seconds(config?.timeout ?? 60),
+        logRetention: RetentionDays.ONE_YEAR,
         reservedConcurrentExecutions: config?.reservedConcurrentExecutions ?? 2,
         code: getAssetCode(simpleLambdaName, config?.singleLambda ?? false),
         handler: `${simpleLambdaName}.handler`,
         environment,
     };
 }
-exports.lambdaFunctionProps = lambdaFunctionProps;
 function getAssetCode(simpleLambdaName, isSingleLambda) {
     const lambdaPath = isSingleLambda
         ? `dist/lambda/`
         : `dist/lambda/${simpleLambdaName}`;
-    return new aws_lambda_1.AssetCode(lambdaPath);
+    return new AssetCode(lambdaPath);
 }
-function defaultLambdaConfiguration(config) {
+export function defaultLambdaConfiguration(config) {
     const props = {
-        runtime: aws_lambda_1.Runtime.NODEJS_16_X,
+        runtime: Runtime.NODEJS_20_X,
         memorySize: config.memorySize ?? 128,
         functionName: config.functionName,
         handler: config.handler,
         environment: config.environment ?? {},
-        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        logRetention: RetentionDays.ONE_YEAR,
         reservedConcurrentExecutions: config.reservedConcurrentExecutions,
         code: config.code,
         role: config.role,
-        timeout: aws_cdk_lib_1.Duration.seconds(config.timeout ?? 10),
+        timeout: Duration.seconds(config.timeout ?? 10),
     };
     if (config.vpc) {
         return {
@@ -68,5 +63,4 @@ function defaultLambdaConfiguration(config) {
     }
     return props;
 }
-exports.defaultLambdaConfiguration = defaultLambdaConfiguration;
 //# sourceMappingURL=lambda-configs.js.map

package/dist/aws/infra/stack/monitoredfunction.d.ts

@@ -1,10 +1,10 @@
 import { Function, FunctionProps } from "aws-cdk-lib/aws-lambda";
 import { Stack } from "aws-cdk-lib";
 import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
-import { DigitrafficStack } from "../stack/stack";
+import { DigitrafficStack } from "./stack.js";
 import { ITopic } from "aws-cdk-lib/aws-sns";
-import { LambdaEnvironment, MonitoredFunctionParameters } from "../stack/lambda-configs";
-import { TrafficType } from "../../../types/traffictype";
+import { LambdaEnvironment, MonitoredFunctionParameters } from "./lambda-configs.js";
+import { TrafficType } from "../../../types/traffictype.js";
 /**
  * Allows customization of CloudWatch Alarm properties
  */

package/dist/aws/infra/stack/monitoredfunction.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonitoredDBFunction = exports.MonitoredFunction = void 0;
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_cloudwatch_actions_1 = require("aws-cdk-lib/aws-cloudwatch-actions");
-const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
-const lambda_configs_1 = require("../stack/lambda-configs");
-const subscription_1 = require("../stack/subscription");
-const lodash_1 = __importDefault(require("lodash"));
+import { Function } from "aws-cdk-lib/aws-lambda";
+import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+import { databaseFunctionProps, } from "./lambda-configs.js";
+import { DigitrafficLogSubscriptions } from "./subscription.js";
+import _ from "lodash";
 /**
  * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
  */
-class MonitoredFunction extends aws_lambda_1.Function {
+export class MonitoredFunction extends Function {
     /**
      * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
      *
@@ -43,12 +37,12 @@ class MonitoredFunction extends aws_lambda_1.Function {
      */
     static createV2(stack, name, environment, functionParameters) {
         const functionName = functionParameters?.functionName ??
-            `${stack.configuration.shortName}-${lodash_1.default.chain(name)
+            `${stack.configuration.shortName}-${_.chain(name)
                 .camelCase()
                 .startCase()
                 .replace(/\s/g, "")
                 .value()}`;
-        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
+        const functionProps = databaseFunctionProps(stack, environment, functionName, name, functionParameters);
         return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
     }
     /**
@@ -67,25 +61,25 @@ class MonitoredFunction extends aws_lambda_1.Function {
             throw new Error("Function name not provided");
         }
         this.givenName = functionProps.functionName;
-        const alarmSnsAction = new aws_cloudwatch_actions_1.SnsAction(alarmSnsTopic);
-        const warningSnsAction = new aws_cloudwatch_actions_1.SnsAction(warningSnsTopic);
+        const alarmSnsAction = new SnsAction(alarmSnsTopic);
+        const warningSnsAction = new SnsAction(warningSnsTopic);
         if (props?.durationAlarmProps?.create !== false) {
             if (!functionProps.timeout) {
                 throw new Error("Timeout needs to be explicitly set");
             }
-            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration", "Duration alarm", `Duration has exceeded ${functionProps.timeout.toSeconds()} seconds`, trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), functionProps.timeout.toMilliseconds(), 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationAlarmProps);
+            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration", "Duration alarm", `Duration has exceeded ${functionProps.timeout.toSeconds()} seconds`, trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), functionProps.timeout.toMilliseconds(), 1, 1, ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationAlarmProps);
         }
         if (props?.durationWarningProps?.create !== false) {
             if (!functionProps.timeout) {
                 throw new Error("Timeout needs to be explicitly set");
             }
-            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration-Warning", "Duration warning", `Duration is 85 % of max ${functionProps.timeout.toSeconds()} seconds`, trafficType, warningSnsAction, functionProps.timeout.toMilliseconds() * 0.85, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationWarningProps);
+            this.createAlarm(scope, this.metricDuration().with({ statistic: "max" }), "Duration-Warning", "Duration warning", `Duration is 85 % of max ${functionProps.timeout.toSeconds()} seconds`, trafficType, warningSnsAction, functionProps.timeout.toMilliseconds() * 0.85, 1, 1, ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.durationWarningProps);
         }
         if (props?.errorAlarmProps?.create !== false) {
-            this.createAlarm(scope, this.metricErrors(), "Errors", "Errors alarm", "Invocations did not succeed", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 1, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.errorAlarmProps);
+            this.createAlarm(scope, this.metricErrors(), "Errors", "Errors alarm", "Invocations did not succeed", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 1, 1, 1, ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, props?.errorAlarmProps);
         }
         if (props?.throttleAlarmProps?.create !== false) {
-            this.createAlarm(scope, this.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 0, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
+            this.createAlarm(scope, this.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 0, 1, 1, ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
         }
     }
     createAlarm(stack, metric, alarmId, alarmName, alarmDescription, trafficType, alarmSnsAction, threshold, evaluationPeriods, datapointsToAlarm, comparisonOperator, alarmProps) {
@@ -104,7 +98,6 @@ class MonitoredFunction extends aws_lambda_1.Function {
         return production ? alarmAction : warningAction;
     }
 }
-exports.MonitoredFunction = MonitoredFunction;
 /** disable all alarms */
 MonitoredFunction.DISABLE_ALARMS = {
     durationAlarmProps: {
@@ -120,7 +113,7 @@ MonitoredFunction.DISABLE_ALARMS = {
         create: false,
     },
 };
-class MonitoredDBFunction {
+export class MonitoredDBFunction {
     /**
      * Create new MonitoredDBFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
      * Grant secret and create log subscription.
@@ -137,20 +130,19 @@ class MonitoredDBFunction {
      */
     static create(stack, name, environment, functionParameters) {
         const functionName = functionParameters?.functionName ??
-            `${stack.configuration.shortName}-${lodash_1.default.chain(name)
+            `${stack.configuration.shortName}-${_.chain(name)
                 .camelCase()
                 .startCase()
                 .replace(/\s/g, "")
                 .value()}`;
         const env = environment ? environment : stack.createLambdaEnvironment();
-        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, env, functionName, name, functionParameters);
+        const functionProps = databaseFunctionProps(stack, env, functionName, name, functionParameters);
         const mf = MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
         stack.grantSecret(mf);
         if (stack.configuration.logsDestinationArn) {
-            new subscription_1.DigitrafficLogSubscriptions(stack, mf);
+            new DigitrafficLogSubscriptions(stack, mf);
         }
         return mf;
     }
 }
-exports.MonitoredDBFunction = MonitoredDBFunction;
 //# sourceMappingURL=monitoredfunction.js.map

package/dist/aws/infra/stack/parameters.d.ts

@@ -1,5 +1,5 @@
 import { StringParameter } from "aws-cdk-lib/aws-ssm";
-import { Construct } from "constructs/lib/construct";
+import { type Construct } from "constructs";
 declare const PARAMETERS: {
     readonly "topic.alarm": {
         readonly parameterName: "/digitraffic/monitoring/alarm-topic";

package/dist/aws/infra/stack/parameters.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParameter = exports.getParameterValue = void 0;
-const aws_ssm_1 = require("aws-cdk-lib/aws-ssm");
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
 const SSM_ROOT = "/digitraffic";
 const MONITORING_ROOT = "/monitoring";
 const DB_ROOT = "/db";
@@ -38,18 +35,16 @@ const PARAMETERS = {
         description: "Proxy writer endpoint",
     },
 };
-function getParameterValue(scope, parameterType) {
+export function getParameterValue(scope, parameterType) {
     const parameterName = PARAMETERS[parameterType].parameterName;
-    return aws_ssm_1.StringParameter.valueForStringParameter(scope, parameterName);
+    return StringParameter.valueForStringParameter(scope, parameterName);
 }
-exports.getParameterValue = getParameterValue;
-function createParameter(scope, parameterType, stringValue) {
+export function createParameter(scope, parameterType, stringValue) {
     const { id, parameterName, description } = PARAMETERS[parameterType];
-    return new aws_ssm_1.StringParameter(scope, id, {
+    return new StringParameter(scope, id, {
         parameterName,
         description,
         stringValue,
     });
 }
-exports.createParameter = createParameter;
 //# sourceMappingURL=parameters.js.map

package/dist/aws/infra/stack/rest_apis.d.ts

@@ -1,9 +1,9 @@
 import { IResource, JsonSchema, Resource, RestApi, RestApiProps } from "aws-cdk-lib/aws-apigateway";
 import { PolicyDocument } from "aws-cdk-lib/aws-iam";
 import { Construct } from "constructs";
-import { ModelWithReference } from "../../types/model-with-reference";
-import { DocumentationPart } from "../documentation";
-import { DigitrafficStack } from "./stack";
+import { ModelWithReference } from "../../types/model-with-reference.js";
+import { DocumentationPart } from "../documentation.js";
+import { DigitrafficStack } from "./stack.js";
 export declare class DigitrafficRestApi extends RestApi {
     readonly apiKeyIds: string[];
     readonly enableDocumentation: boolean;