@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

package/dist/aws/infra/canaries/url-checker.js

@@ -0,0 +1,256 @@
+import synthetics from "Synthetics";
+import zlib from "node:zlib";
+import { Asserter } from "../../../__test__/asserter.js";
+import { isValidGeoJson } from "../../../utils/geometry.js";
+import { logException } from "../../../utils/logging.js";
+import { getEnvVariable } from "../../../utils/utils.js";
+import { getApiKeyFromAPIGateway } from "../../runtime/apikey.js";
+import { logger } from "../../runtime/dt-logger-default.js";
+import { MediaType } from "../../types/mediatypes.js";
+import { ENV_API_KEY, ENV_HOSTNAME } from "./canary-keys.js";
+export const API_KEY_HEADER = "x-api-key";
+const baseHeaders = {
+    "Digitraffic-User": "internal-digitraffic-canary",
+    "Accept-Encoding": "gzip",
+    Accept: "*/*",
+};
+// Step name can only contain letters, numbers, hyphens, underscores, periods, and spaces
+function sanitizeStepName(url) {
+    return url.replace(/auth=.*/, "").replace(/[^a-zA-Z0-9\-_. ]/g, " ");
+}
+export class UrlChecker {
+    requestOptions;
+    constructor(hostname, apiKey) {
+        const headers = { ...baseHeaders };
+        if (apiKey) {
+            headers[API_KEY_HEADER] = apiKey;
+        }
+        this.requestOptions = {
+            hostname,
+            method: "GET",
+            protocol: "https:",
+            headers,
+        };
+        synthetics.getConfiguration().disableRequestMetrics();
+        synthetics
+            .getConfiguration()
+            .withIncludeRequestBody(false)
+            .withIncludeRequestHeaders(false)
+            .withIncludeResponseBody(false)
+            .withIncludeResponseHeaders(false)
+            .withFailedCanaryMetric(true);
+    }
+    static async create(hostname, apiKeyId) {
+        const apiKey = await getApiKeyFromAPIGateway(apiKeyId);
+        return new UrlChecker(hostname, apiKey.value);
+    }
+    static createV2() {
+        return UrlChecker.create(getEnvVariable(ENV_HOSTNAME), getEnvVariable(ENV_API_KEY));
+    }
+    async expectStatus(statusCode, url, callback) {
+        const requestOptions = {
+            ...this.requestOptions,
+            ...{
+                path: url,
+            },
+        };
+        await synthetics.executeHttpStep(`Verify ${statusCode} for ${sanitizeStepName(url)}`, requestOptions, callback);
+    }
+    expect200(url, ...callbacks) {
+        const callback = async (json, body, res) => {
+            await Promise.allSettled(callbacks.map((c) => c(json, body, res)));
+        };
+        return this.expectStatus(200, url, callback);
+    }
+    expect404(url) {
+        const requestOptions = {
+            ...this.requestOptions,
+            ...{
+                path: url,
+            },
+        };
+        return synthetics.executeHttpStep(`Verify 404 for ${sanitizeStepName(url)}`, requestOptions, validateStatusCodeAndContentType(404, MediaType.TEXT_PLAIN));
+    }
+    expect400(url) {
+        const requestOptions = {
+            ...this.requestOptions,
+            ...{
+                path: url,
+            },
+        };
+        return synthetics.executeHttpStep(`Verify 400 for ${sanitizeStepName(url)}`, requestOptions, validateStatusCodeAndContentType(400, MediaType.TEXT_PLAIN));
+    }
+    expect403WithoutApiKey(url, mediaType) {
+        if (!this.requestOptions.headers ||
+            !(API_KEY_HEADER in this.requestOptions.headers) ||
+            !this.requestOptions.headers[API_KEY_HEADER]) {
+            logger.error({
+                method: "UrlChecker.expect403WithoutApiKey",
+                message: "No Api-key defined",
+            });
+        }
+        const requestOptions = {
+            ...this.requestOptions,
+            ...{
+                path: url,
+                headers: baseHeaders,
+            },
+        };
+        return synthetics.executeHttpStep(`Verify 403 for ${sanitizeStepName(url)}`, requestOptions, validateStatusCodeAndContentType(403, mediaType ?? MediaType.APPLICATION_JSON));
+    }
+    done() {
+        return "Canary successful";
+    }
+}
+async function getResponseBody(response) {
+    const body = await getBodyFromResponse(response);
+    if (response.headers["content-encoding"] === "gzip") {
+        try {
+            return zlib.gunzipSync(body).toString();
+        }
+        catch (e) {
+            logException(logger, e);
+        }
+    }
+    return body.toString();
+}
+function getBodyFromResponse(response) {
+    return new Promise((resolve) => {
+        const buffers = [];
+        response.on("data", (data) => {
+            buffers.push(data);
+        });
+        response.on("end", () => {
+            resolve(Buffer.concat(buffers).toString());
+        });
+    });
+}
+/**
+ * Returns function, that validates that the status code and content-type from response are the given values
+ * @param statusCode
+ * @param contentType
+ */
+function validateStatusCodeAndContentType(statusCode, contentType) {
+    return (res) => {
+        return new Promise((resolve) => {
+            if (res.statusCode !== statusCode) {
+                throw new Error(`${res.statusCode ?? undefined} ${res.statusMessage ?? undefined}`);
+            }
+            if (res.headers["content-type"] !== contentType) {
+                throw new Error(`Wrong content-type ${res.headers["content-type"] ?? undefined}`);
+            }
+            resolve();
+        });
+    };
+}
+// DEPRECATED
+export class ResponseChecker {
+    contentType;
+    checkCors = true;
+    constructor(contentType) {
+        this.contentType = contentType;
+    }
+    static forJson() {
+        return new ResponseChecker(MediaType.APPLICATION_JSON);
+    }
+    static forCSV() {
+        return new ResponseChecker(MediaType.TEXT_CSV);
+    }
+    static forGeojson() {
+        return new ResponseChecker(MediaType.APPLICATION_GEOJSON);
+    }
+    static forJpeg() {
+        return new ResponseChecker(MediaType.IMAGE_JPEG);
+    }
+    check() {
+        return this.responseChecker(() => {
+            // no need to do anything
+        });
+    }
+    checkJson(fn) {
+        return this.responseChecker((body, res) => {
+            fn(JSON.parse(body), body, res);
+        });
+    }
+    responseChecker(fn) {
+        return async (res) => {
+            if (!res.statusCode) {
+                throw new Error("statusCode missing");
+            }
+            if (res.statusCode < 200 || res.statusCode > 299) {
+                throw new Error(`${res.statusCode} ${res.statusMessage ?? undefined}`);
+            }
+            if (this.checkCors && !res.headers["access-control-allow-origin"]) {
+                throw new Error("CORS missing");
+            }
+            if (res.headers["content-type"] !== this.contentType) {
+                throw new Error(`Wrong content-type ${res.headers["content-type"] ?? undefined}`);
+            }
+            const body = await getResponseBody(res);
+            fn(body, res);
+        };
+    }
+}
+export const ContentChecker = {
+    checkJson(fn) {
+        return async (res) => {
+            const body = await getResponseBody(res);
+            fn(JSON.parse(body), body, res);
+        };
+    },
+    checkResponse(fn) {
+        return async (res) => {
+            const body = await getResponseBody(res);
+            fn(body, res);
+        };
+    },
+};
+export const ContentTypeChecker = {
+    checkContentType(contentType) {
+        return (res) => {
+            if (!res.statusCode) {
+                throw new Error("statusCode missing");
+            }
+            if (res.statusCode < 200 || res.statusCode > 299) {
+                throw new Error(`${res.statusCode} ${res.statusMessage ?? undefined}`);
+            }
+            if (!res.headers["access-control-allow-origin"]) {
+                throw new Error("CORS missing");
+            }
+            if (res.headers["content-type"] !== contentType) {
+                throw new Error(`Wrong content-type ${res.headers["content-type"] ?? undefined}`);
+            }
+            return Promise.resolve();
+        };
+    },
+};
+export const GeoJsonChecker = {
+    validFeatureCollection(fn) {
+        return ResponseChecker.forGeojson().checkJson((json) => {
+            Asserter.assertEquals(json.type, "FeatureCollection");
+            Asserter.assertTrue(isValidGeoJson(json));
+            if (fn) {
+                fn(json);
+            }
+        });
+    },
+};
+export const HeaderChecker = {
+    checkHeaderExists(headerName) {
+        return (res) => {
+            if (!res.headers[headerName]) {
+                throw new Error(`Missing header: ${headerName}`);
+            }
+            return Promise.resolve();
+        };
+    },
+    checkHeaderMissing(headerName) {
+        return (res) => {
+            if (res.headers[headerName]) {
+                throw new Error(`Header should not exist: ${headerName}`);
+            }
+            return Promise.resolve();
+        };
+    },
+};
+//# sourceMappingURL=url-checker.js.map

package/dist/aws/infra/documentation.d.ts

@@ -0,0 +1,56 @@
+import type { Resource } from "aws-cdk-lib/aws-apigateway";
+import type { Construct } from "constructs";
+/**
+ * Add description to a query parameter
+ * @param name query parameter name
+ * @param description query parameter description
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ */
+export declare function addQueryParameterDescription(name: string, description: string, resource: Resource, stack: Construct): void;
+/**
+ * Add a documentation part to a method
+ * @param methodDescription
+ * @param documentationProperties
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addDocumentation(methodDescription: string, documentationProperties: object, resource: Resource, stack: Construct): void;
+/**
+ * Adds OpenAPI tags to an API method
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addTags(methodDescription: string, tags: string[], resource: Resource, stack: Construct): void;
+/**
+ * Adds OpenAPI tags and a method summary to an API method
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ *
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param summary OpenAPI summary
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export declare function addTagsAndSummary(methodDescription: string, tags: string[], summary: string, resource: Resource, stack: Construct): void;
+export interface DocumentationProperties {
+    description?: string;
+    tags?: string[];
+    summary?: string;
+    deprecated?: boolean;
+}
+export declare class DocumentationPart {
+    readonly parameterName: string;
+    readonly type: string;
+    readonly documentationProperties: DocumentationProperties;
+    private constructor();
+    deprecated(note: string): this;
+    static queryParameter(parameterName: string, description: string): DocumentationPart;
+    static pathParameter(parameterName: string, description: string): DocumentationPart;
+    static method(tags: string[], name: string, summary: string): DocumentationPart;
+}

package/dist/aws/infra/documentation.js

@@ -0,0 +1,90 @@
+import { CfnDocumentationPart } from "aws-cdk-lib/aws-apigateway";
+// Documentation parts are objects that describe an API Gateway API or parts of an API
+// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-documenting-api.html
+/**
+ * Add description to a query parameter
+ * @param name query parameter name
+ * @param description query parameter description
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ */
+export function addQueryParameterDescription(name, description, resource, stack) {
+    new CfnDocumentationPart(stack, `${name}Documentation`, {
+        restApiId: resource.api.restApiId,
+        location: {
+            type: "QUERY_PARAMETER",
+            name,
+            path: resource.path,
+        },
+        properties: JSON.stringify({ description }),
+    });
+}
+/**
+ * Add a documentation part to a method
+ * @param methodDescription
+ * @param documentationProperties
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export function addDocumentation(methodDescription, documentationProperties, resource, stack) {
+    new CfnDocumentationPart(stack, `${methodDescription}Documentation`, {
+        restApiId: resource.api.restApiId,
+        location: {
+            type: "METHOD",
+            path: resource.path,
+        },
+        properties: JSON.stringify(documentationProperties),
+    });
+}
+/**
+ * Adds OpenAPI tags to an API method
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export function addTags(methodDescription, tags, resource, stack) {
+    addDocumentation(methodDescription, { tags }, resource, stack);
+}
+/**
+ * Adds OpenAPI tags and a method summary to an API method
+ *
+ * @deprecated Use DigitrafficRestApi.documentResource
+ *
+ * @param methodDescription Description of API method
+ * @param tags OpenAPI tags
+ * @param summary OpenAPI summary
+ * @param resource REST API resource
+ * @param stack CloudFormation stack
+ */
+export function addTagsAndSummary(methodDescription, tags, summary, resource, stack) {
+    addDocumentation(methodDescription, { tags, summary }, resource, stack);
+}
+export class DocumentationPart {
+    parameterName;
+    type;
+    documentationProperties;
+    constructor(parameterName, documentationProperties, type) {
+        this.parameterName = parameterName;
+        this.documentationProperties = documentationProperties;
+        this.type = type;
+    }
+    deprecated(note) {
+        // deprecated is not supported ATM: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html
+        this.documentationProperties.deprecated = true;
+        this.documentationProperties.summary += `. ${note}`;
+        return this;
+    }
+    static queryParameter(parameterName, description) {
+        return new DocumentationPart(parameterName, { description }, "QUERY_PARAMETER");
+    }
+    static pathParameter(parameterName, description) {
+        return new DocumentationPart(parameterName, { description }, "PATH_PARAMETER");
+    }
+    static method(tags, name, summary) {
+        return new DocumentationPart(name, { tags, summary }, "METHOD");
+    }
+}
+//# sourceMappingURL=documentation.js.map

package/dist/aws/infra/import-util.d.ts

@@ -0,0 +1,17 @@
+import type { Stack } from "aws-cdk-lib";
+import type { IVpc } from "aws-cdk-lib/aws-ec2";
+import type { Construct } from "constructs";
+/**
+ * Import VPC from other stack outputs
+ */
+export declare function importVpc(scope: Construct, environmentName: string): IVpc;
+/**
+ * Import value from other stack output.  Stack outputs are named with
+ * digitraffic-${environmentName}-${name} pattern and this function takes care of it
+ */
+export declare function importValue(environmentName: string, name: string): string;
+/**
+ * Export value as stack output.  Use same naming pattern as importValue.
+ */
+export declare function exportValue(stack: Stack, environmentName: string, name: string, value: string): void;
+export declare function outputName(environmentName: string, name: string): string;

package/dist/aws/infra/import-util.js

@@ -0,0 +1,41 @@
+import { CfnOutput, Fn } from "aws-cdk-lib";
+import { Vpc } from "aws-cdk-lib/aws-ec2";
+/**
+ * Import VPC from other stack outputs
+ */
+export function importVpc(scope, environmentName) {
+    const vpcId = importValue(environmentName, "VPCID");
+    const privateSubnetIds = [
+        importValue(environmentName, "digitrafficprivateASubnet"),
+        importValue(environmentName, "digitrafficprivateBSubnet"),
+    ];
+    const availabilityZones = ["euw1-az1", "euw1-az2"];
+    // VPC reference construction requires vpcId and availability zones
+    // private subnets are used in Lambda configuration
+    return Vpc.fromVpcAttributes(scope, "vpc", {
+        vpcId,
+        privateSubnetIds,
+        availabilityZones,
+    });
+}
+/**
+ * Import value from other stack output.  Stack outputs are named with
+ * digitraffic-${environmentName}-${name} pattern and this function takes care of it
+ */
+export function importValue(environmentName, name) {
+    return Fn.importValue(outputName(environmentName, name));
+}
+/**
+ * Export value as stack output.  Use same naming pattern as importValue.
+ */
+export function exportValue(stack, environmentName, name, value) {
+    const exportName = outputName(environmentName, name);
+    new CfnOutput(stack, exportName, {
+        exportName,
+        value,
+    });
+}
+export function outputName(environmentName, name) {
+    return `digitraffic-${environmentName}-${name}`;
+}
+//# sourceMappingURL=import-util.js.map

package/dist/aws/infra/scheduler.d.ts

@@ -0,0 +1,12 @@
+import { Duration } from "aws-cdk-lib";
+import { Rule, Schedule } from "aws-cdk-lib/aws-events";
+import type { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import type { Construct } from "constructs";
+export declare class Scheduler extends Rule {
+    constructor(stack: Construct, ruleName: string, schedule: Schedule, lambda?: AWSFunction);
+    static everyMinute(stack: Construct, ruleName: string, lambda?: AWSFunction): Scheduler;
+    static everyMinutes(stack: Construct, ruleName: string, minutes: number, lambda?: AWSFunction): Scheduler;
+    static everyHour(stack: Construct, ruleName: string, lambda?: AWSFunction): Scheduler;
+    static everyDay(stack: Construct, ruleName: string, lambda?: AWSFunction): Scheduler;
+    static every(stack: Construct, ruleName: string, duration: Duration, lambda?: AWSFunction): Scheduler;
+}

package/dist/aws/infra/scheduler.js

@@ -0,0 +1,27 @@
+import { Duration } from "aws-cdk-lib";
+import { Rule, Schedule } from "aws-cdk-lib/aws-events";
+import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
+export class Scheduler extends Rule {
+    constructor(stack, ruleName, schedule, lambda) {
+        super(stack, ruleName, { ruleName, schedule });
+        if (lambda) {
+            this.addTarget(new LambdaFunction(lambda));
+        }
+    }
+    static everyMinute(stack, ruleName, lambda) {
+        return Scheduler.every(stack, ruleName, Duration.minutes(1), lambda);
+    }
+    static everyMinutes(stack, ruleName, minutes, lambda) {
+        return Scheduler.every(stack, ruleName, Duration.minutes(minutes), lambda);
+    }
+    static everyHour(stack, ruleName, lambda) {
+        return Scheduler.every(stack, ruleName, Duration.hours(1), lambda);
+    }
+    static everyDay(stack, ruleName, lambda) {
+        return Scheduler.every(stack, ruleName, Duration.days(1), lambda);
+    }
+    static every(stack, ruleName, duration, lambda) {
+        return new Scheduler(stack, ruleName, Schedule.rate(duration), lambda);
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/aws/infra/security-rule.d.ts

@@ -0,0 +1,12 @@
+import { Rule } from "aws-cdk-lib/aws-events";
+import type { ITopic } from "aws-cdk-lib/aws-sns";
+import type { Construct } from "constructs";
+/**
+ * Automatic rule for Security Hub.  Send notification to given topic if the following conditions apply:
+ * * There is a finding with a status of NEW
+ * * It has severity of HIGH or CRITICAL
+ * * It is in a FAILED state
+ */
+export declare class DigitrafficSecurityRule extends Rule {
+    constructor(scope: Construct, topic: ITopic);
+}

package/dist/aws/infra/security-rule.js

@@ -0,0 +1,35 @@
+import { Rule } from "aws-cdk-lib/aws-events";
+import { SnsTopic } from "aws-cdk-lib/aws-events-targets";
+/**
+ * Automatic rule for Security Hub.  Send notification to given topic if the following conditions apply:
+ * * There is a finding with a status of NEW
+ * * It has severity of HIGH or CRITICAL
+ * * It is in a FAILED state
+ */
+export class DigitrafficSecurityRule extends Rule {
+    constructor(scope, topic) {
+        const ruleName = "SecurityHubRule";
+        super(scope, ruleName, {
+            ruleName,
+            eventPattern: {
+                source: ["aws.securityhub"],
+                detailType: ["Security Hub Findings - Imported"],
+                detail: {
+                    findings: {
+                        Compliance: {
+                            Status: ["FAILED"],
+                        },
+                        Workflow: {
+                            Status: ["NEW"],
+                        },
+                        Severity: {
+                            Label: ["HIGH", "CRITICAL"],
+                        },
+                    },
+                },
+            },
+        });
+        this.addTarget(new SnsTopic(topic));
+    }
+}
+//# sourceMappingURL=security-rule.js.map

package/dist/aws/infra/sqs-integration.d.ts

@@ -0,0 +1,4 @@
+import type { IModel, RequestValidator, Resource } from "aws-cdk-lib/aws-apigateway";
+import type { Queue } from "aws-cdk-lib/aws-sqs";
+import type { Construct } from "constructs";
+export declare function attachQueueToApiGatewayResource(stack: Construct, queue: Queue, resource: Resource, requestValidator: RequestValidator, resourceName: string, apiKeyRequired: boolean, requestModels?: Record<string, IModel>): void;

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

@@ -0,0 +1,85 @@
+import { Aws } from "aws-cdk-lib";
+import { AwsIntegration, PassthroughBehavior, } from "aws-cdk-lib/aws-apigateway";
+import { PolicyStatement, Role, ServicePrincipal } from "aws-cdk-lib/aws-iam";
+export function attachQueueToApiGatewayResource(stack, queue, resource, requestValidator, resourceName, apiKeyRequired, requestModels) {
+    // role for API Gateway
+    const apiGwRole = new Role(stack, `${resourceName}APIGatewayToSQSRole`, {
+        assumedBy: new ServicePrincipal("apigateway.amazonaws.com"),
+    });
+    // grants API Gateway the right to send SQS messages
+    apiGwRole.addToPolicy(new PolicyStatement({
+        resources: [queue.queueArn],
+        actions: ["sqs:SendMessage"],
+    }));
+    // grants API Gateway the right write CloudWatch Logs
+    apiGwRole.addToPolicy(new PolicyStatement({
+        resources: ["*"],
+        actions: [
+            "logs:CreateLogGroup",
+            "logs:CreateLogStream",
+            "logs:DescribeLogGroups",
+            "logs:DescribeLogStreams",
+            "logs:PutLogEvents",
+            "logs:GetLogEvents",
+            "logs:FilterLogEvents",
+        ],
+    }));
+    // create an integration between API Gateway and an SQS queue
+    const fifoMessageGroupId = queue.fifo
+        ? "&MessageGroupId=AlwaysSameFifoGroup"
+        : "";
+    const sqsIntegration = new AwsIntegration({
+        service: "sqs",
+        integrationHttpMethod: "POST",
+        options: {
+            passthroughBehavior: PassthroughBehavior.NEVER,
+            credentialsRole: apiGwRole,
+            requestParameters: {
+                // SQS requires the Content-Type of the HTTP request to be application/x-www-form-urlencoded
+                "integration.request.header.Content-Type": "'application/x-www-form-urlencoded'",
+            },
+            requestTemplates: {
+                // map the JSON request to a form parameter, FIFO needs also MessageGroupId
+                // https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html
+                "application/json": `Action=SendMessage${fifoMessageGroupId}&MessageBody=$util.urlEncode($input.body)`,
+            },
+            // these are required by SQS
+            integrationResponses: [
+                {
+                    statusCode: "200",
+                    responseTemplates: {
+                        "text/html": "Success",
+                    },
+                },
+                {
+                    statusCode: "500",
+                    responseTemplates: {
+                        "text/html": "Error",
+                    },
+                    selectionPattern: "500",
+                },
+            ],
+        },
+        path: `${Aws.ACCOUNT_ID}/${queue.queueName}`,
+    });
+    resource.addMethod("POST", sqsIntegration, {
+        requestValidator,
+        apiKeyRequired,
+        requestModels: requestModels ?? {},
+        methodResponses: [
+            {
+                statusCode: "200",
+                responseParameters: {
+                    "method.response.header.Content-Type": true,
+                },
+            },
+            {
+                statusCode: "500",
+                responseParameters: {
+                    "method.response.header.Content-Type": true,
+                },
+            },
+        ],
+    });
+}
+//# sourceMappingURL=sqs-integration.js.map

package/dist/aws/infra/sqs-queue.d.ts

@@ -0,0 +1,19 @@
+import type { QueueProps } from "aws-cdk-lib/aws-sqs";
+import { Queue } from "aws-cdk-lib/aws-sqs";
+import type { DigitrafficStack } from "./stack/stack.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.
+ */
+export declare class DigitrafficSqsQueue extends Queue {
+    static create(stack: DigitrafficStack, name: string, props: QueueProps): DigitrafficSqsQueue;
+    /**
+     * Create a fifo with given name.  No DLQ created!
+     */
+    static createFifo(stack: DigitrafficStack, name: string, props: QueueProps): DigitrafficSqsQueue;
+}
+export declare const DigitrafficDLQueue: {
+    create(stack: DigitrafficStack, name: string): DigitrafficSqsQueue;
+};