@digitraffic/common 2022.11.22-1 → 2022.11.23-test

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

@@ -0,0 +1,45 @@
+import { Stack, StackProps } from "aws-cdk-lib";
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { ISecurityGroup } from "aws-cdk-lib/aws-ec2/lib/security-group";
+import { ITopic } from "aws-cdk-lib/aws-sns";
+import { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+import { TrafficType } from "../../../types/traffictype";
+import { DBLambdaEnvironment } from "./lambda-configs";
+export declare const SOLUTION_KEY = "Solution";
+export declare const SSM_KEY_WARNING_TOPIC: string;
+export declare const SSM_KEY_ALARM_TOPIC: string;
+export interface StackConfiguration {
+    readonly shortName: string;
+    readonly secretId?: string;
+    readonly alarmTopicArn: string;
+    readonly warningTopicArn: string;
+    readonly logsDestinationArn?: string;
+    readonly vpcId?: string;
+    readonly lambdaDbSgId?: string;
+    readonly privateSubnetIds?: string[];
+    readonly availabilityZones?: string[];
+    readonly trafficType: TrafficType;
+    readonly production: boolean;
+    readonly stackProps: StackProps;
+    readonly stackFeatures?: {
+        readonly enableCanaries?: boolean;
+        readonly enableDocumentation?: boolean;
+    };
+    readonly whitelistedResources?: string[];
+}
+export declare class DigitrafficStack extends Stack {
+    readonly vpc?: IVpc;
+    readonly lambdaDbSg?: ISecurityGroup;
+    readonly alarmTopic: ITopic;
+    readonly warningTopic: ITopic;
+    readonly secret?: ISecret;
+    readonly configuration: StackConfiguration;
+    constructor(scope: Construct, id: string, configuration: StackConfiguration);
+    addAspects(): void;
+    createLambdaEnvironment(): DBLambdaEnvironment;
+    createDefaultLambdaEnvironment(dbApplication: string): DBLambdaEnvironment;
+    getSecret(): ISecret;
+    grantSecret(...lambdas: AWSFunction[]): void;
+}

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

@@ -0,0 +1,17 @@
+import { CfnSubscriptionFilter } from "aws-cdk-lib/aws-logs";
+import { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
+import { DigitrafficStack } from "./stack";
+import { Construct } from "constructs";
+import { MonitoredFunction } from "./monitoredfunction";
+/**
+ * Creates a subscription filter that subscribes to a Lambda Log Group and delivers the logs to another destination.
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-subscriptionfilter.html
+ * @param lambda The Lambda function, needed to create a dependency
+ * @param lambdaName The Lambda name from which the Log Group name is derived
+ * @param logDestinationArn Destination for streamed logs
+ * @param stack CloudFormation stack
+ */
+export declare function createSubscription(lambda: AWSFunction, lambdaName: string, logDestinationArn: string | undefined, stack: Construct): CfnSubscriptionFilter | undefined;
+export declare class DigitrafficLogSubscriptions {
+    constructor(stack: DigitrafficStack, ...lambdas: MonitoredFunction[]);
+}

package/dist/aws/infra/stacks/db-dns-stack.d.ts

@@ -0,0 +1,11 @@
+import { Stack } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { InfraStackConfiguration } from "./intra-stack-configuration";
+/**
+ * Creates a dns local zone and creates records for cluster endpoints and proxy endpoints.
+ *
+ */
+export declare class DbDnsStack extends Stack {
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration);
+    createDnsRecords(isc: InfraStackConfiguration): void;
+}

package/dist/aws/infra/stacks/db-proxy-stack.d.ts

@@ -0,0 +1,19 @@
+import { Stack } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { CfnDBProxyEndpoint, DatabaseProxy } from "aws-cdk-lib/aws-rds";
+import { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { InfraStackConfiguration } from "./intra-stack-configuration";
+import { DbConfiguration } from "./db-stack";
+/**
+ * A stack that creates a Database proxy.
+ */
+export declare class DbProxyStack extends Stack {
+    static PROXY_READER_EXPORT_NAME: string;
+    static PROXY_WRITER_EXPORT_NAME: string;
+    readonly isc: InfraStackConfiguration;
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration, configuration: DbConfiguration);
+    createProxy(vpc: IVpc, secret: ISecret, configuration: DbConfiguration): DatabaseProxy;
+    createProxyEndpoints(vpc: IVpc, proxy: DatabaseProxy, securityGroupId: string): CfnDBProxyEndpoint;
+    setOutputs(configuration: DbConfiguration, proxy: DatabaseProxy, proxyEndpoint: CfnDBProxyEndpoint): void;
+}

package/dist/aws/infra/stacks/db-stack.d.ts

@@ -0,0 +1,31 @@
+import { Stack } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { AuroraPostgresEngineVersion, DatabaseCluster } from "aws-cdk-lib/aws-rds";
+import { InstanceType } from "aws-cdk-lib/aws-ec2";
+import { InfraStackConfiguration } from "./intra-stack-configuration";
+export interface DbConfiguration {
+    readonly secretArn: string;
+    readonly dbVersion: AuroraPostgresEngineVersion;
+    readonly dbInstanceType: InstanceType;
+    readonly snapshotIdentifier: string;
+    readonly instances: number;
+    readonly customParameterGroup: boolean;
+    readonly securityGroupId: string;
+    readonly dbProxyName?: string;
+}
+/**
+ * How to upgrade major version?
+ * 0. Set correct SG for db-stack and db-proxy-stack(this step will be removed in the future)
+ * 1. Update db-stack WITHOUT parameter group
+ * 2. Upgrade extensions by hand
+ * 3. Upgrade database from the AWS console
+ * 4. Update db-stack with the upgraded version and custom parameter group
+ */
+export declare class DbStack extends Stack {
+    static CLUSTER_IDENTIFIER_EXPORT_NAME: string;
+    static CLUSTER_READ_ENDPOINT_EXPORT_NAME: string;
+    static CLUSTER_WRITE_ENDPOINT_EXPORT_NAME: string;
+    static CLUSTER_PORT: number;
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration, configuration: DbConfiguration);
+    createAuroraCluster(isc: InfraStackConfiguration, configuration: DbConfiguration): DatabaseCluster;
+}

package/dist/aws/infra/stacks/intra-stack-configuration.d.ts

@@ -0,0 +1,5 @@
+import { Environment } from "aws-cdk-lib";
+export interface InfraStackConfiguration {
+    readonly env: Environment;
+    readonly environmentName: string;
+}

package/dist/aws/infra/stacks/network-stack.d.ts

@@ -0,0 +1,12 @@
+import { Stack } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { Vpc } from "aws-cdk-lib/aws-ec2";
+import { InfraStackConfiguration } from "./intra-stack-configuration";
+export interface NetworkConfiguration {
+    readonly vpcName: string;
+    readonly cidr: string;
+}
+export declare class NetworkStack extends Stack {
+    constructor(scope: Construct, id: string, isc: InfraStackConfiguration, configuration: NetworkConfiguration);
+    createVpc(configuration: NetworkConfiguration): Vpc;
+}

package/dist/aws/infra/usage-plans.d.ts

@@ -0,0 +1,16 @@
+import { IApiKey, RestApi } from "aws-cdk-lib/aws-apigateway";
+/**
+ * Creates an usage plan for a REST API with a single API key
+ * @param api The REST API
+ * @param apiKeyId Id for the API key, this is a surrogate id for CDK, not displayed anywhere
+ * @param apiKeyName Name for the API key, this is displayed in the AWS Console
+ * @deprecated Creates randomized API key names, use createDefaultUsagePlan instead
+ */
+export declare function createUsagePlan(api: RestApi, apiKeyId: string, apiKeyName: string): IApiKey;
+/**
+ * Creates a default usage plan for a REST API with a single API key
+ * @param api The REST API
+ * @param apiName Name of the api. Will generate key: apiName + ' API Key' and plan: apiName + ' API Usage Plan'
+ * @param value Optional value for the API key
+ */
+export declare function createDefaultUsagePlan(api: RestApi, apiName: string, value?: string): IApiKey;

package/dist/aws/runtime/apikey.d.ts

@@ -0,0 +1,2 @@
+import { APIGateway } from "aws-sdk";
+export declare function getApiKeyFromAPIGateway(keyId: string): Promise<APIGateway.Types.ApiKey>;

package/dist/aws/runtime/digitraffic-integration-response.d.ts

@@ -0,0 +1,8 @@
+import { IntegrationResponse } from "aws-cdk-lib/aws-apigateway";
+import { MediaType } from "../types/mediatypes";
+export declare abstract class DigitrafficIntegrationResponse {
+    static ok(mediaType: MediaType): IntegrationResponse;
+    static badRequest(mediaType?: MediaType): IntegrationResponse;
+    static notImplemented(mediaType?: MediaType): IntegrationResponse;
+    static create(statusCode: string, mediaType: MediaType): IntegrationResponse;
+}

package/dist/aws/runtime/environment.d.ts

@@ -0,0 +1 @@
+export declare function envValue(key: string, defaultValue?: string): string;

package/dist/aws/runtime/messaging.d.ts

@@ -0,0 +1,10 @@
+import { SNS } from "aws-sdk";
+/**
+ * Utility function for publishing SNS messages.
+ * Made because using *await* with AWS APIs doesn't require calling promise() but nothing works if it isn't called.
+ * Retries a single time in case of failure.
+ * @param message
+ * @param topicArn
+ * @param sns
+ */
+export declare function snsPublish(message: string, topicArn: string, sns: SNS): Promise<void>;

package/dist/aws/runtime/s3.d.ts

@@ -0,0 +1,2 @@
+import { S3 } from "aws-sdk";
+export declare function uploadToS3<Body extends S3.Body | undefined>(bucketName: string, body: Body, objectName: string, cannedAcl?: string, contentType?: string): Promise<void>;

package/dist/aws/runtime/secrets/dbsecret.d.ts

@@ -0,0 +1,55 @@
+import { GenericSecret } from "./secret";
+export type DbSecret = {
+    readonly username: string;
+    readonly password: string;
+    readonly host: string;
+    readonly ro_host: string;
+};
+export declare enum RdsProxySecretKey {
+    username = "username",
+    password = "password",
+    proxy_host = "proxy_host",
+    proxy_ro_host = "proxy_ro_host"
+}
+export declare enum RdsSecretKey {
+    username = "username",
+    password = "password",
+    host = "host",
+    ro_host = "ro_host"
+}
+export type RdsProxySecret = Record<RdsProxySecretKey, string>;
+export type RdsSecret = Record<RdsSecretKey, string>;
+export declare enum DatabaseEnvironmentKeys {
+    DB_USER = "DB_USER",
+    DB_PASS = "DB_PASS",
+    DB_URI = "DB_URI",
+    DB_RO_URI = "DB_RO_URI",
+    DB_APPLICATION = "DB_APPLICATION"
+}
+/**
+ * You can give the following options for retrieving a secret:
+ *
+ * expectedKeys: the list of keys the secret must include.  If not, an error will be thrown.
+ * prefix: a prefix that's included in retrieved secret's keys.  Only keys begining with the prefix will be included.
+ * The secret that is passed to the given function will not include the prefix in it's keys.
+
+ */
+export type SecretOptions = {
+    readonly expectedKeys?: string[];
+    readonly prefix?: string;
+};
+export type SecretToPromiseFunction<Secret, Response = void> = (secret: Secret) => Promise<Response> | void;
+export type SecretFunction<Secret, Response = void> = (secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions) => Promise<Response | void>;
+export type EmptySecretFunction<Response = void> = SecretFunction<DbSecret, Response>;
+/**
+ * Run the given function with secret retrieved from Secrets Manager.  Also injects database-credentials into environment.
+ *
+ * @deprecated use SecretHolder & ProxyHolder
+ * @see SecretOptions
+ *
+ * @param {string} secretId
+ * @param {function} fn
+ * @param {SecretOptions} options
+ */
+export declare function withDbSecret<Secret, Response>(secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions): Promise<Response | void>;
+export declare function checkExpectedSecretKeys<Secret extends GenericSecret>(keys: string[], secret: Secret): void;

package/dist/aws/runtime/secrets/proxy-holder.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Holds credentials for RDS Proxy access.
+ */
+export declare class ProxyHolder {
+    private readonly secretHolder;
+    constructor(secretId: string);
+    static create(): ProxyHolder;
+    setCredentials(): Promise<void>;
+}

package/dist/aws/runtime/secrets/rds-holder.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Holds credentials for RDS access.
+ */
+export declare class RdsHolder {
+    private readonly secretHolder;
+    constructor(secretId: string);
+    static create(): RdsHolder;
+    setCredentials(): Promise<void>;
+}

package/dist/aws/runtime/secrets/secret-holder.d.ts

@@ -0,0 +1,27 @@
+import { GenericSecret } from "./secret";
+/**
+ * Utility class for getting secrets from Secret Manager.
+ * Supports prefix for secrets, checking of expected keys and ttl-configuration.
+ *
+ * By default, secrets are cached for 5 minutes and then reread from the Secrets Manager(This can be overridden with configuration).
+ *
+ * Supports setting the database environment paramaters from the secret too.
+ */
+export declare class SecretHolder<Secret extends GenericSecret> {
+    private readonly secretId;
+    private readonly prefix;
+    private readonly expectedKeys;
+    private readonly secretCache;
+    constructor(secretId: string, prefix?: string, expectedKeys?: string[], configuration?: {
+        ttl: number;
+    });
+    private initSecret;
+    static create<S extends GenericSecret>(prefix?: string, expectedKeys?: string[]): SecretHolder<S>;
+    get(): Promise<Secret>;
+    private parseSecret;
+    private getSecret;
+    /**
+     * @deprecated Use ProxyHolder
+     */
+    setDatabaseCredentials(): Promise<void>;
+}

package/dist/aws/runtime/secrets/secret.d.ts

@@ -0,0 +1,8 @@
+import { SecretToPromiseFunction } from "./dbsecret";
+export type GenericSecret = Record<string, string>;
+/**
+ @deprecated use SecretHolder & ProxyHolder
+ */
+export declare function withSecret<Secret, Response>(secretId: string, fn: SecretToPromiseFunction<Secret, Response>): Promise<Response | void>;
+export declare function getSecret<Secret>(secretId: string, prefix?: string): Promise<Secret>;
+export declare function withSecretAndPrefix<Secret, Response>(secretId: string, prefix: string, fn: SecretToPromiseFunction<Secret, Response>): Promise<Response | void>;

package/dist/aws/types/errors.d.ts

@@ -0,0 +1,8 @@
+export declare const NOT_FOUND_MESSAGE = "NOT_FOUND";
+export declare const ERROR_MESSAGE = "ERROR";
+export declare const OK_MESSAGE = "OK";
+export declare const BAD_REQUEST_MESSAGE = "BAD REQUEST";
+export declare class ValidationError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, body: string);
+}

package/dist/aws/types/lambda-response.d.ts

@@ -0,0 +1,13 @@
+export declare class LambdaResponse<T> {
+    readonly status: number;
+    readonly body: T;
+    readonly fileName?: string;
+    constructor(status: number, body: T, fileName?: string);
+    static ok<T>(body: T, fileName?: string): Promise<LambdaResponse<T>>;
+    static okJson<T>(json: T, fileName?: string): Promise<LambdaResponse<string>>;
+    static badRequest(body: string): Promise<LambdaResponse<string>>;
+    static notFound(): Promise<LambdaResponse<string>>;
+    static internalError(): Promise<LambdaResponse<string>>;
+    static notImplemented(): Promise<LambdaResponse<string>>;
+    static create<T>(status: number, body: T, fileName?: string): Promise<LambdaResponse<T>>;
+}

package/dist/aws/types/mediatypes.d.ts

@@ -0,0 +1,11 @@
+export declare enum MediaType {
+    APPLICATION_JSON = "application/json",
+    APPLICATION_XML = "application/xml",
+    APPLICATION_GEOJSON = "application/geo+json;charset=UTF-8",
+    IMAGE_SVG = "image/svg+xml",
+    IMAGE_JPEG = "image/jpeg",
+    TEXT_PLAIN = "text/plain",
+    TEXT_HTML = "text/html",
+    TEXT_CSV = "text/csv",
+    APPLICATION_JSON_UTF8 = "application/json;charset=UTF-8"
+}

package/dist/aws/types/model-with-reference.d.ts

@@ -0,0 +1,7 @@
+import { Model } from "aws-cdk-lib/aws-apigateway";
+/**
+ * Model object with a reference to an API Gateway model object.
+ */
+export interface ModelWithReference extends Model {
+    modelReference: string;
+}

package/dist/aws/types/proxytypes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
+ *
+ * Not fully described, extend if necessary.
+ */
+export type ProxyLambdaResponse = {
+    readonly statusCode: number;
+    readonly body: string;
+    readonly headers?: Record<string, string>;
+    readonly multiValueHeaders?: Record<string, string[]>;
+};
+/**
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
+ *
+ * Not fully described, extend if necessary.
+ */
+export type ProxyLambdaRequest = {
+    readonly resource: string;
+    readonly path: string;
+    readonly httpMethod: string;
+    readonly headers: Record<string, string>;
+    readonly multiValueHeaders: Record<string, string[]>;
+    readonly queryStringParameters: Record<string, string>;
+    readonly multiValueQueryStringParameters: Record<string, string[]>;
+    readonly body?: string;
+};

package/dist/aws/types/tags.d.ts

@@ -0,0 +1,2 @@
+export declare const BETA_TAGS: string[];
+export declare const DATA_V1_TAGS: string[];

package/dist/database/cached.d.ts

@@ -0,0 +1,7 @@
+import { DTDatabase, DTTransaction } from "./database";
+export declare enum JSON_CACHE_KEY {
+    NAUTICAL_WARNINGS_ACTIVE = "nautical-warnings-active",
+    NAUTICAL_WARNINGS_ARCHIVED = "nautical-warnings-archived"
+}
+export declare function updateCachedJson<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY, value: T): Promise<null>;
+export declare function getJsonFromCache<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY): Promise<T | null>;

package/dist/database/database.d.ts

@@ -0,0 +1,19 @@
+import { IDatabase, ITask } from "pg-promise";
+export type DTDatabase = IDatabase<unknown>;
+export type DTTransaction = ITask<unknown>;
+/**
+ * Creates a non-pooling database connection primarily used by Lambdas.
+ *
+ * Note! Using this method opens a new RDS connection on every invocation. It is advised to
+ * use RDS proxy to pool connections transparently.
+ * https://docs.amazonaws.cn/en_us/AmazonRDS/latest/AuroraUserGuide/rds-proxy.html
+ * @param username Username
+ * @param password Password
+ * @param applicationName name of application
+ * @param url Connection URL
+ * @param options pg-promise options
+ */
+export declare function initDbConnection(username: string, password: string, applicationName: string, url: string, options?: object): DTDatabase;
+export declare function inTransaction<T>(fn: (db: DTTransaction) => Promise<T>): Promise<T>;
+export declare function inDatabase<T>(fn: (db: DTDatabase) => Promise<T>): Promise<T>;
+export declare function inDatabaseReadonly<T>(fn: (db: DTDatabase) => Promise<T>): Promise<T>;

package/dist/database/last-updated.d.ts

@@ -0,0 +1,16 @@
+import { DTDatabase, DTTransaction } from "./database";
+export declare enum DataType {
+    VS_DATEX2 = "VS_DATEX2",
+    COUNTING_SITES_DATA = "COUNTING_SITES_DATA",
+    COUNTING_SITES_METADATA = "COUNTING_SITES_METADATA",
+    COUNTING_SITES_METADATA_CHECK = "COUNTING_SITES_METADATA_CHECK",
+    MAINTENANCE_TRACKING_DATA_CHECKED = "MAINTENANCE_TRACKING_DATA_CHECKED",
+    PERMIT_DATA = "PERMIT_DATA",
+    PERMIT_DATA_CHECK = "PERMIT_DATA_CHECK"
+}
+export declare function getLastUpdated(db: DTDatabase, datatype: DataType): Promise<Date | null>;
+export declare function getLastUpdatedWithSubtype(db: DTDatabase, datatype: DataType, subtype: string): Promise<Date | null>;
+export declare function updateLastUpdated(db: DTDatabase | DTTransaction, datatype: DataType, updated: Date): Promise<null>;
+export declare function updateLastUpdatedWithSubtype(db: DTDatabase | DTTransaction, datatype: DataType, subtype: string, updated: Date): Promise<null>;
+export declare function getUpdatedTimestamp(db: DTDatabase, datatype: string): Promise<Date | null>;
+export declare function updateUpdatedTimestamp(db: DTDatabase | DTTransaction, datatype: string, date: Date, by?: string): Promise<null>;

package/dist/database/models.d.ts

@@ -0,0 +1,6 @@
+export interface Countable {
+    count: number;
+}
+export interface Identifiable<T> {
+    id: T;
+}

package/dist/marine/id_utils.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidIMO(imo: number): boolean;
+export declare function isValidMMSI(mmsi: number): boolean;
+export declare function isValidLOCODE(locode: string): boolean;

package/dist/marine/rtz.d.ts

@@ -0,0 +1,48 @@
+export type RtzPositionCoordinate = {
+    readonly $: {
+        readonly lat: number;
+        readonly lon: number;
+    };
+};
+export type RtzWaypointPosition = {
+    readonly position: RtzPositionCoordinate[];
+};
+export type RtzWaypoint = {
+    readonly waypoint: RtzWaypointPosition[];
+};
+export type RtzScheduleElement = {
+    readonly $: {
+        /**
+         * Date
+         */
+        readonly etd?: string;
+        /**
+         * Date
+         */
+        readonly eta?: string;
+    };
+};
+export type RtzSchedule = {
+    readonly scheduleElement: RtzScheduleElement[];
+};
+export type RtzScheduleWrapper = {
+    readonly manual?: RtzSchedule[];
+    readonly calculated?: RtzSchedule[];
+};
+export type RtzSchedules = {
+    readonly schedule: RtzScheduleWrapper[];
+};
+export type RtzRouteInfo = {
+    readonly $: {
+        readonly vesselMMSI: string;
+        readonly vesselIMO: string;
+    };
+};
+export type RtzRoute = {
+    readonly routeInfo: RtzRouteInfo[];
+    readonly waypoints: RtzWaypoint[];
+    readonly schedules: RtzSchedules[];
+};
+export type RtzVoyagePlan = {
+    readonly route: RtzRoute;
+};

package/dist/test/asserter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A simple asserter-class for writing canaries without dependency to testing-libraries.
+ */
+export declare abstract class Asserter {
+    static assertEquals<T>(value: T, expected: T): void;
+    static assertTrue<T>(value: T): void;
+    static assertLength<T>(data: T[], expected: number): void;
+    static assertLengthGreaterThan<T>(data: T[], expected: number): void;
+    static assertGreaterThan(value: number, expected: number): void;
+    static assertToBeCloseTo(value: number, expected: number, delta: number): void;
+}

package/dist/test/db-testutils.d.ts

@@ -0,0 +1,3 @@
+import { DTDatabase } from "../database/database";
+export declare function assertCount(db: DTDatabase, sql: string, count: number): Promise<void>;
+export declare function dbTestBase(fn: (db: DTDatabase) => void, truncateFn: (db: DTDatabase) => Promise<void>, dbUser: string, dbPass: string, dbUri: string): () => void;

package/dist/test/httpserver.d.ts

@@ -0,0 +1,19 @@
+export declare const ERROR_NO_MATCH = "NO MATCH";
+export declare const ERRORCODE_NOT_FOUND = 404;
+/**
+ * A mock HTTP server created for testing connections from a Lambda to an outside integration
+ */
+export declare class TestHttpServer {
+    private server?;
+    private debug;
+    private messageStack;
+    constructor();
+    getCallCount(): number;
+    getRequestBody(callNumber: number): string;
+    listen(port: number, props: ListenProperties, debug?: boolean, statusCode?: number): void;
+    close(): void;
+    private debuglog;
+}
+export interface ListenProperties {
+    [key: string]: (url?: string, data?: string) => string;
+}

package/dist/test/secret.d.ts

@@ -0,0 +1,3 @@
+import { EmptySecretFunction, SecretFunction } from "../aws/runtime/secrets/dbsecret";
+export declare function createSecretFunction<Secret, Response>(secret: Secret): SecretFunction<Secret, Response>;
+export declare function createEmptySecretFunction<Response>(): EmptySecretFunction<Response>;

package/dist/test/secrets-manager.d.ts

@@ -0,0 +1,9 @@
+import * as sinon from "sinon";
+/**
+ * Stub Secrets Manager for tests.  You must call this
+ * before you instantiate Secrets Manager(this might happen when you import the function that uses Secrets Manager).
+ *
+ * To mock the actual secret, call mockSecret()
+ */
+export declare function stubSecretsManager(): sinon.SinonStub<any[], any>;
+export declare function mockSecret<Secret>(secret: Secret): void;

package/dist/test/testutils.d.ts

@@ -0,0 +1,12 @@
+export declare function randomString(): string;
+export declare function getRandomNumber(min: number, max: number): number;
+export declare function getRandomNumberAsString(min: number, max: number): string;
+export declare function getRandomInteger(min: number, max: number): number;
+export declare function getRandomIntegerAsString(min: number, max: number): string;
+export declare function getRandomBigInt(min: number, max: number): bigint;
+export declare function randomBoolean(): boolean;
+/**
+ * Returns a new copy of an array, shuffled using Math.random()
+ * @param array Array
+ */
+export declare function shuffle<T>(array: T[]): T[];

package/dist/types/either.d.ts

@@ -0,0 +1,9 @@
+export type EitherOk<T> = {
+    result: "ok";
+    value: T;
+};
+export type EitherError = {
+    result: "error";
+    message: string;
+};
+export type Either<T> = EitherOk<T> | EitherError;

package/dist/types/input-error.d.ts

@@ -0,0 +1,2 @@
+export declare class InputError extends Error {
+}

package/dist/types/language.d.ts

@@ -0,0 +1,5 @@
+export declare enum Language {
+    FI = "fi",
+    EN = "en",
+    SV = "sv"
+}

package/dist/types/traffictype.d.ts

@@ -0,0 +1,8 @@
+export declare enum TrafficType {
+    ROAD = "Road",
+    MARINE = "Marine",
+    RAIL = "Rail",
+    AVIATION = "Aviation",
+    MCP = "MCP",
+    OTHER = "Other"
+}

package/dist/types/validator.d.ts

@@ -0,0 +1,4 @@
+export declare const MIN_YEAR = 1900;
+export declare const MAX_YEAR = 2100;
+export declare function validateYear(year: number, minYear?: number, maxYear?: number): boolean;
+export declare function validateMonth(month: number): boolean;