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

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

@@ -0,0 +1,44 @@
+import type { IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
+import type { Role } from "aws-cdk-lib/aws-iam";
+import type { Code, FunctionProps } from "aws-cdk-lib/aws-lambda";
+import { Architecture, Runtime } from "aws-cdk-lib/aws-lambda";
+import type { ILogGroup } from "aws-cdk-lib/aws-logs";
+import type { MonitoredFunctionAlarmProps } from "./monitoredfunction.js";
+import type { DigitrafficStack } from "./stack.js";
+export type LambdaEnvironment = Record<string, string>;
+export type DBLambdaEnvironment = LambdaEnvironment & {
+    SECRET_ID?: string;
+    DB_APPLICATION: string;
+};
+/**
+ * @deprecated use dt-function.ts: FunctionBuilder
+ */
+export declare function databaseFunctionProps(stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, logGroup: ILogGroup, config?: Partial<FunctionParameters>): FunctionProps;
+/**
+ * @deprecated use dt-function.ts: FunctionBuilder
+ */
+export declare function lambdaFunctionProps(_: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, logGroup: ILogGroup, config?: Partial<FunctionParameters>): FunctionProps;
+export declare function defaultLambdaConfiguration(config: FunctionParameters): FunctionProps;
+export interface FunctionParameters {
+    memorySize?: number;
+    timeout?: number;
+    functionName?: string;
+    code: Code;
+    handler: string;
+    logGroup: ILogGroup;
+    readOnly?: boolean;
+    environment?: Record<string, string>;
+    reservedConcurrentExecutions?: number;
+    role?: Role;
+    vpc?: IVpc;
+    vpcSubnets?: SubnetSelection;
+    runtime?: Runtime;
+    architecture?: Architecture;
+    singleLambda?: boolean;
+}
+export type MonitoredFunctionParameters = FunctionParameters & {
+    readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly durationWarningProps?: MonitoredFunctionAlarmProps;
+    readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
+};

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

@@ -0,0 +1,71 @@
+import { Duration } from "aws-cdk-lib";
+import { Architecture, AssetCode, Runtime } from "aws-cdk-lib/aws-lambda";
+/**
+ * @deprecated use dt-function.ts: FunctionBuilder
+ */
+export function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName, logGroup, config) {
+    const vpcSubnets = stack.vpc
+        ? {
+            subnets: stack.vpc.privateSubnets,
+        }
+        : undefined;
+    return {
+        ...lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, logGroup, config),
+        ...{
+            vpc: stack.vpc ?? undefined,
+            vpcSubnets,
+            securityGroup: stack.lambdaDbSg ?? undefined,
+        },
+    };
+}
+/**
+ * @deprecated use dt-function.ts: FunctionBuilder
+ */
+export function lambdaFunctionProps(_, environment, lambdaName, simpleLambdaName, logGroup, config) {
+    return {
+        runtime: config?.runtime ?? Runtime.NODEJS_24_X,
+        architecture: config?.architecture ?? Architecture.ARM_64,
+        memorySize: config?.memorySize ?? 128,
+        functionName: lambdaName,
+        role: config?.role,
+        timeout: Duration.seconds(config?.timeout ?? 60),
+        logGroup: logGroup,
+        reservedConcurrentExecutions: config?.reservedConcurrentExecutions ?? 2,
+        code: getAssetCode(simpleLambdaName, config?.singleLambda ?? false),
+        handler: `${simpleLambdaName}.handler`,
+        environment,
+    };
+}
+function getAssetCode(simpleLambdaName, isSingleLambda) {
+    const lambdaPath = isSingleLambda
+        ? `dist/lambda/`
+        : `dist/lambda/${simpleLambdaName}`;
+    return new AssetCode(lambdaPath);
+}
+export function defaultLambdaConfiguration(config) {
+    const props = {
+        runtime: Runtime.NODEJS_24_X,
+        memorySize: config.memorySize ?? 128,
+        functionName: config.functionName,
+        handler: config.handler,
+        environment: config.environment ?? {},
+        logGroup: config.logGroup,
+        reservedConcurrentExecutions: config.reservedConcurrentExecutions,
+        code: config.code,
+        role: config.role,
+        timeout: Duration.seconds(config.timeout ?? 10),
+    };
+    if (config.vpc) {
+        return {
+            ...props,
+            ...{
+                vpc: config.vpc,
+                vpcSubnets: {
+                    subnets: config.vpc.privateSubnets,
+                },
+            },
+        };
+    }
+    return props;
+}
+//# sourceMappingURL=lambda-configs.js.map

package/dist/aws/infra/stack/lambda-log-group.d.ts

@@ -0,0 +1,15 @@
+import type { Stack } from "aws-cdk-lib";
+import { LogGroup, RetentionDays } from "aws-cdk-lib/aws-logs";
+import type { DigitrafficStackLike } from "./stack.js";
+export interface CreateLambdaLogGroupParams {
+    functionName: string;
+    retention?: RetentionDays;
+}
+export interface CreateLambdaLogGroupParamsForStack extends CreateLambdaLogGroupParams {
+    stack: Stack;
+    shortName: string;
+}
+export interface CreateLambdaLogGroupParamsForDigitrafficStack extends CreateLambdaLogGroupParams {
+    stack: Stack & DigitrafficStackLike;
+}
+export declare function createLambdaLogGroup(params: CreateLambdaLogGroupParamsForStack | CreateLambdaLogGroupParamsForDigitrafficStack): LogGroup;

package/dist/aws/infra/stack/lambda-log-group.js

@@ -0,0 +1,24 @@
+import { LogGroup, RetentionDays } from "aws-cdk-lib/aws-logs";
+function isCreateLambdaLogGroupParamsForDigitrafficStack(params) {
+    return !!("configuration" in params.stack && params.stack?.configuration?.shortName);
+}
+export function createLambdaLogGroup(params) {
+    const _createLambdaLogGroup = (stack, functionName, shortName, retention) => {
+        return new LogGroup(stack, `${functionName}-LogGroup`, {
+            logGroupName: `/${shortName}/lambda/${functionName}`,
+            retention,
+        });
+    };
+    const getShortName = (params) => {
+        if (isCreateLambdaLogGroupParamsForDigitrafficStack(params)) {
+            return params.stack.configuration.shortName;
+        }
+        else {
+            return params.shortName;
+        }
+    };
+    const { functionName, retention = RetentionDays.ONE_YEAR } = params;
+    const shortName = getShortName(params);
+    return _createLambdaLogGroup(params.stack, functionName, shortName, retention);
+}
+//# sourceMappingURL=lambda-log-group.js.map

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

@@ -0,0 +1,85 @@
+import type { Stack } from "aws-cdk-lib";
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+import type { FunctionProps } from "aws-cdk-lib/aws-lambda";
+import { Function as LambdaFunction } from "aws-cdk-lib/aws-lambda";
+import type { ITopic } from "aws-cdk-lib/aws-sns";
+import type { TrafficType } from "../../../types/traffictype.js";
+import type { LambdaEnvironment, MonitoredFunctionParameters } from "./lambda-configs.js";
+import type { DigitrafficStack } from "./stack.js";
+/**
+ * Allows customization of CloudWatch Alarm properties
+ */
+export interface MonitoredFunctionAlarmProps {
+    /**
+     * Setting this to false will not create a CloudWatch alarm
+     */
+    readonly create: boolean;
+    readonly threshold?: number;
+    readonly evaluationPeriods?: number;
+    readonly datapointsToAlarm?: number;
+    readonly comparisonOperator?: ComparisonOperator;
+}
+export interface MonitoredFunctionProps {
+    readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly durationWarningProps?: MonitoredFunctionAlarmProps;
+    readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
+}
+/**
+ * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
+ */
+export declare class MonitoredFunction extends LambdaFunction {
+    readonly givenName: string;
+    /** disable all alarms */
+    static readonly DISABLE_ALARMS: MonitoredFunctionProps;
+    /**
+     * @param scope Stack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param alarmSnsTopic SNS topic for alarms
+     * @param warningSnsTopic SNS topic for warnings
+     * @param production Is the stack a production stack, used for determining the alarm topic
+     * @param trafficType Traffic type, used for alarm names. Set to null if Lambda is not related to any traffic type.
+     * @param props Monitored function properties
+     */
+    constructor(scope: Stack, id: string, functionProps: FunctionProps, alarmSnsTopic: ITopic, warningSnsTopic: ITopic, production: boolean, trafficType: TrafficType | null, props?: MonitoredFunctionProps);
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
+     *
+     * @param stack DigitrafficStack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param props Monitored function properties
+     */
+    static create(stack: DigitrafficStack, id: string, functionProps: FunctionProps, props?: Partial<MonitoredFunctionProps>): MonitoredFunction;
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static createV2(stack: DigitrafficStack, name: string, environment: LambdaEnvironment, functionParameters?: Partial<MonitoredFunctionParameters>): MonitoredFunction;
+    private createAlarm;
+    private getAlarmActionForEnv;
+}
+export declare const MonitoredDBFunction: {
+    /**
+     * Create new MonitoredDBFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     * Grant secret.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * If you don't need to pass any extra arguments to lambda-environment, you can leave environment out and this function will create the
+     * default Lambda Environment with SECRET_ID and DB_APPLICATION.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    create(stack: DigitrafficStack, name: string, environment?: LambdaEnvironment, functionParameters?: Partial<MonitoredFunctionParameters>): MonitoredFunction;
+};

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

@@ -0,0 +1,147 @@
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
+import { ApplicationLogLevel, Function as LambdaFunction, LoggingFormat, SystemLogLevel, } from "aws-cdk-lib/aws-lambda";
+import { camelCase, startCase } from "es-toolkit";
+import { databaseFunctionProps } from "./lambda-configs.js";
+import { createLambdaLogGroup } from "./lambda-log-group.js";
+/**
+ * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
+ */
+export class MonitoredFunction extends LambdaFunction {
+    givenName;
+    /** disable all alarms */
+    static DISABLE_ALARMS = {
+        durationAlarmProps: {
+            create: false,
+        },
+        durationWarningProps: {
+            create: false,
+        },
+        errorAlarmProps: {
+            create: false,
+        },
+        throttleAlarmProps: {
+            create: false,
+        },
+    };
+    /**
+     * @param scope Stack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param alarmSnsTopic SNS topic for alarms
+     * @param warningSnsTopic SNS topic for warnings
+     * @param production Is the stack a production stack, used for determining the alarm topic
+     * @param trafficType Traffic type, used for alarm names. Set to null if Lambda is not related to any traffic type.
+     * @param props Monitored function properties
+     */
+    constructor(scope, id, functionProps, alarmSnsTopic, warningSnsTopic, production, trafficType, props) {
+        // Set default loggingFormat to JSON if not explicitly set to TEXT
+        super(scope, id, {
+            ...{
+                loggingFormat: LoggingFormat.JSON,
+                applicationLogLevelV2: ApplicationLogLevel.DEBUG,
+                systemLogLevelV2: SystemLogLevel.INFO,
+            },
+            ...functionProps,
+        });
+        if (functionProps.functionName === undefined) {
+            throw new Error("Function name not provided");
+        }
+        this.givenName = functionProps.functionName;
+        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, 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, 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, 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, ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
+        }
+    }
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
+     *
+     * @param stack DigitrafficStack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param props Monitored function properties
+     */
+    static create(stack, id, functionProps, props) {
+        if (props === MonitoredFunction.DISABLE_ALARMS &&
+            stack.configuration.production) {
+            throw new Error(`Function ${functionProps.functionName ?? undefined} has DISABLE_ALARMS.  Remove before installing to production or define your own properties!`);
+        }
+        return new MonitoredFunction(stack, id, functionProps, stack.alarmTopic, stack.warningTopic, stack.configuration.production, stack.configuration.trafficType, props);
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static createV2(stack, name, environment, functionParameters) {
+        const functionName = functionParameters?.functionName ??
+            `${stack.configuration.shortName}-${startCase(camelCase(name)).replace(/\s/g, "")}`;
+        const logGroup = createLambdaLogGroup({ stack, functionName });
+        const functionProps = databaseFunctionProps(stack, environment, functionName, name, logGroup, functionParameters);
+        return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
+    }
+    createAlarm(stack, metric, alarmId, alarmName, alarmDescription, trafficType, alarmSnsAction, threshold, evaluationPeriods, datapointsToAlarm, comparisonOperator, alarmProps) {
+        metric
+            .createAlarm(stack, `${this.node.id}-${alarmId}`, {
+            alarmName: `${trafficType ?? ""} ${stack.stackName} ${this.functionName} ${alarmName}`.trim(),
+            alarmDescription,
+            threshold: alarmProps?.threshold ?? threshold,
+            evaluationPeriods: alarmProps?.evaluationPeriods ?? evaluationPeriods,
+            datapointsToAlarm: alarmProps?.datapointsToAlarm ?? datapointsToAlarm,
+            comparisonOperator: alarmProps?.comparisonOperator ?? comparisonOperator,
+        })
+            .addAlarmAction(alarmSnsAction);
+    }
+    getAlarmActionForEnv(alarmAction, warningAction, production) {
+        return production ? alarmAction : warningAction;
+    }
+}
+export const MonitoredDBFunction = {
+    /**
+     * Create new MonitoredDBFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     * Grant secret.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * If you don't need to pass any extra arguments to lambda-environment, you can leave environment out and this function will create the
+     * default Lambda Environment with SECRET_ID and DB_APPLICATION.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    create(stack, name, environment, functionParameters) {
+        const functionName = functionParameters?.functionName ??
+            `${stack.configuration.shortName}-${startCase(camelCase(name)).replace(/\s/g, "")}`;
+        const logGroup = createLambdaLogGroup({ stack, functionName });
+        const env = environment ? environment : stack.createLambdaEnvironment();
+        const functionProps = databaseFunctionProps(stack, env, functionName, name, logGroup, functionParameters);
+        const mf = MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
+        stack.grantSecret(mf);
+        return mf;
+    },
+};
+//# sourceMappingURL=monitoredfunction.js.map

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

@@ -0,0 +1,40 @@
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import type { Construct } from "constructs";
+declare const PARAMETERS: {
+    readonly "topic.alarm": {
+        readonly parameterName: "/digitraffic/monitoring/alarm-topic";
+    };
+    readonly "topic.warning": {
+        readonly parameterName: "/digitraffic/monitoring/warning-topic";
+    };
+    readonly "cluster.reader": {
+        readonly id: "ClusterReaderEndpointParameter";
+        readonly parameterName: "/digitraffic/db/reader-endpoint";
+        readonly description: "Cluster reader endpoint";
+    };
+    readonly "cluster.writer": {
+        readonly id: "ClusterWriterEndpointParameter";
+        readonly parameterName: "/digitraffic/db/writer-endpoint";
+        readonly description: "Cluster writer endpoint";
+    };
+    readonly "cluster.identifier": {
+        readonly id: "ClusterIdentifierParameter";
+        readonly parameterName: "/digitraffic/db/identifier";
+        readonly description: "Cluster identifier";
+    };
+    readonly "proxy.reader": {
+        readonly id: "ProxyReaderEndpointParameter";
+        readonly parameterName: "/digitraffic/db/proxy-reader-endpoint";
+        readonly description: "Proxy reader endpoint";
+    };
+    readonly "proxy.writer": {
+        readonly id: "ProxyWriterEndpointParameter";
+        readonly parameterName: "/digitraffic/db/proxy-writer-endpoint";
+        readonly description: "Proxy writer endpoint";
+    };
+};
+export type ReadParameterType = keyof typeof PARAMETERS;
+export type WriteParameterType = Exclude<Exclude<ReadParameterType, "topic.alarm">, "topic.warning">;
+export declare function getParameterValue(scope: Construct, parameterType: ReadParameterType): string;
+export declare function createParameter(scope: Construct, parameterType: WriteParameterType, stringValue: string): StringParameter;
+export {};

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

@@ -0,0 +1,50 @@
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
+const SSM_ROOT = "/digitraffic";
+const MONITORING_ROOT = "/monitoring";
+const DB_ROOT = "/db";
+const PARAMETERS = {
+    "topic.alarm": {
+        parameterName: `${SSM_ROOT}${MONITORING_ROOT}/alarm-topic`,
+    },
+    "topic.warning": {
+        parameterName: `${SSM_ROOT}${MONITORING_ROOT}/warning-topic`,
+    },
+    "cluster.reader": {
+        id: "ClusterReaderEndpointParameter",
+        parameterName: `${SSM_ROOT}${DB_ROOT}/reader-endpoint`,
+        description: "Cluster reader endpoint",
+    },
+    "cluster.writer": {
+        id: "ClusterWriterEndpointParameter",
+        parameterName: `${SSM_ROOT}${DB_ROOT}/writer-endpoint`,
+        description: "Cluster writer endpoint",
+    },
+    "cluster.identifier": {
+        id: "ClusterIdentifierParameter",
+        parameterName: `${SSM_ROOT}${DB_ROOT}/identifier`,
+        description: "Cluster identifier",
+    },
+    "proxy.reader": {
+        id: "ProxyReaderEndpointParameter",
+        parameterName: `${SSM_ROOT}${DB_ROOT}/proxy-reader-endpoint`,
+        description: "Proxy reader endpoint",
+    },
+    "proxy.writer": {
+        id: "ProxyWriterEndpointParameter",
+        parameterName: `${SSM_ROOT}${DB_ROOT}/proxy-writer-endpoint`,
+        description: "Proxy writer endpoint",
+    },
+};
+export function getParameterValue(scope, parameterType) {
+    const parameterName = PARAMETERS[parameterType].parameterName;
+    return StringParameter.valueForStringParameter(scope, parameterName);
+}
+export function createParameter(scope, parameterType, stringValue) {
+    const { id, parameterName, description } = PARAMETERS[parameterType];
+    return new StringParameter(scope, id, {
+        parameterName,
+        description,
+        stringValue,
+    });
+}
+//# sourceMappingURL=parameters.js.map

package/dist/aws/infra/stack/rest-api.d.ts

@@ -0,0 +1,74 @@
+import type { Stack } from "aws-cdk-lib";
+import type { IResource, JsonSchema, Resource, ResourceOptions, RestApiProps } from "aws-cdk-lib/aws-apigateway";
+import { RestApi } from "aws-cdk-lib/aws-apigateway";
+import { PolicyDocument } from "aws-cdk-lib/aws-iam";
+import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import type { Construct } from "constructs";
+import type { ModelWithReference } from "../../types/model-with-reference.js";
+import type { DocumentationPart } from "../documentation.js";
+import type { DigitrafficStackLike } from "./stack.js";
+export declare const PUBLIC_REST_API_CORS_CONFIG: {
+    readonly defaultCorsPreflightOptions: {
+        readonly allowOrigins: string[];
+        readonly allowHeaders: ["Content-Type", "X-Amz-Date", "Authorization", "X-Api-Key", "X-Amz-Security-Token", "Digitraffic-User"];
+        readonly allowMethods: ["OPTIONS", "GET", "HEAD"];
+    };
+};
+export interface ExportParams {
+    /** Set apiKeyId when needed */
+    readonly apiKeyId?: string;
+    /** Override exportName, default is stack shortname */
+    readonly exportName?: string;
+}
+export declare class DigitrafficRestApi extends RestApi {
+    readonly apiKeyIds: string[];
+    readonly enableDocumentation: boolean;
+    private readonly _stack;
+    constructor(stack: Stack & DigitrafficStackLike, apiId: string, apiName: string, allowFromIpAddresses?: string[] | undefined, config?: Partial<RestApiProps>);
+    hostname(): string;
+    /** Export end point and api key to Parameter store */
+    exportEndpoint(): [StringParameter, StringParameter];
+    /** Export end point and given api key to Parameter store */
+    exportEndpoint(params: ExportParams): [StringParameter, StringParameter];
+    /**
+     * @param apiKeyId
+     * @param apiKeyName
+     * @deprecated Uses deprecated createUsagePlan that creates randomized API key names, use createUsagePlanV2 instead
+     */
+    createUsagePlan(apiKeyId: string, apiKeyName: string): string;
+    createUsagePlanV2(apiName: string, apiKey?: string): string;
+    addJsonModel(modelName: string, schema: JsonSchema): ModelWithReference;
+    addCSVModel(modelName: string): ModelWithReference;
+    private getModelWithReference;
+    private addDocumentationPart;
+    documentResource(resource: Resource, ...documentationPart: DocumentationPart[]): void;
+    addResourceWithCorsOptionsSubTree(resource: Resource, pathPart: string, config?: ResourceOptions): Resource;
+    /**
+     * Add support for HTTP OPTIONS to an API GW resource,
+     * this is required for preflight CORS requests made by browsers.
+     * @param apiResource
+     */
+    addCorsOptions(apiResource: IResource): void;
+}
+/**
+ * Due to AWS API design API Gateway will always return 403 'Missing Authentication Token' for requests
+ * with a non-existent endpoint. This function translates this response to a 404.
+ * Requests with an invalid or missing API key are not affected (still return 403 'Forbidden').
+ * @param restApi RestApi
+ * @param stack Construct
+ */
+export declare function add404Support(restApi: RestApi, stack: Construct): void;
+export declare function add401Support(restApi: RestApi, stack: Construct): void;
+/**
+ * Due to AWS API design API Gateway will always return 403 'Missing Authentication Token' for requests
+ * with a non-existent endpoint. This function converts this response to a custom one.
+ * Requests with an invalid or missing API key are not affected (still return 403 'Forbidden').
+ * @param returnCode
+ * @param message
+ * @param restApi RestApi
+ * @param stack Construct
+ */
+export declare function setReturnCodeForMissingAuthenticationToken(returnCode: number, message: string, restApi: RestApi, stack: Construct): void;
+export declare function createRestApi(stack: Construct, apiId: string, apiName: string, allowFromIpAddresses?: string[] | undefined): RestApi;
+export declare function createDefaultPolicyDocument(): PolicyDocument;
+export declare function createIpRestrictionPolicyDocument(allowFromIpAddresses: string[]): PolicyDocument;