@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/types/http/event-util.d.ts

@@ -0,0 +1,47 @@
+import { APIGatewayEvent, APIGatewayEventRequestContext, AuthResponseContext } from 'aws-lambda';
+import { EpsilonLoggerConfig } from '../config/epsilon-logger-config';
+import { BasicAuthToken } from './auth/basic-auth-token';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+/**
+ * Endpoints about the api itself
+ */
+export declare class EventUtil {
+    private constructor();
+    static extractStage(event: APIGatewayEvent): string;
+    static extractHostHeader(event: APIGatewayEvent): string;
+    static extractProtocol(event: APIGatewayEvent): string;
+    static extractApiGatewayStage(event: APIGatewayEvent): string;
+    static extractRequestContext(event: APIGatewayEvent): APIGatewayEventRequestContext;
+    static extractAuthorizer(event: APIGatewayEvent): AuthResponseContext;
+    static ipAddressChain(event: APIGatewayEvent): string[];
+    static ipAddress(event: APIGatewayEvent): string;
+    static extractFullPath(event: APIGatewayEvent, overrideProtocol?: string): string;
+    static extractFullPrefix(event: APIGatewayEvent, overrideProtocol?: string): string;
+    static jsonBodyToObject(event: APIGatewayEvent): any;
+    static calcLogLevelViaEventOrEnvParam(curLevel: LoggerLevelName, event: APIGatewayEvent, rConfig: EpsilonLoggerConfig): LoggerLevelName;
+    /**
+     * This is a weird function - sometimes your customers will not decode their query params and it
+     * results in query params that look like 'amp;SOMETHING' instead of 'SOMETHING'.  This function
+     * looks for params that look like that, and strips the amp; from them.  If you have any
+     * params you are expecting that have 'amp;' in front of them, DON'T use this function.
+     *
+     * Also, you are a moron for having a param that looks like that
+     *
+     * Yes, it would be better to fix this on the client side, but that is not always an option
+     * in production
+     * @param event
+     */
+    static fixStillEncodedQueryParams(event: APIGatewayEvent): void;
+    /**
+     * Allows you to force in a token for an arbitrary event without having to pass the whole thing
+     * through Epsilon.  Useful for when you need to test a handler that needs authorization,
+     * and don't need to instantiate all of epsilon, just the handler
+     * @param event Event to decorate
+     * @param jwtToken String containing a valid JWT token
+     */
+    static applyTokenToEventForTesting(event: APIGatewayEvent, jwtToken: string): void;
+    static extractBasicAuthenticationToken(event: APIGatewayEvent, throwErrorOnMissingBad?: boolean): BasicAuthToken;
+    static eventIsAGraphQLIntrospection(event: APIGatewayEvent): boolean;
+    static extractAuthorizationHeaderCaseInsensitive(evt: APIGatewayEvent): string;
+    static extractBearerTokenFromEvent(evt: APIGatewayEvent): string;
+}

package/dist/types/http/response-util.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { ProxyResult } from 'aws-lambda';
+import { EpsilonHttpError } from './error/epsilon-http-error';
+export declare class ResponseUtil {
+    private constructor();
+    static errorResponse<T>(err: EpsilonHttpError<T>): ProxyResult;
+    static redirect(target: string, code?: number, queryParams?: any): ProxyResult;
+    static coerceToProxyResult(input: any): ProxyResult;
+    static applyGzipIfPossible(encodingHeader: string, proxyResult: ProxyResult): Promise<ProxyResult>;
+    static gzip(input: Buffer): Promise<Buffer>;
+}

package/dist/types/http/route/epsilon-router.d.ts

@@ -0,0 +1,8 @@
+import { RouteMapping } from './route-mapping';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { HttpConfig } from '../../config/http/http-config';
+export interface EpsilonRouter {
+    routes: RouteMapping[];
+    openApiModelValidator: ModelValidator;
+    config: HttpConfig;
+}

package/dist/types/http/route/extended-auth-response-context.d.ts

@@ -0,0 +1,6 @@
+import { AuthResponseContext } from 'aws-lambda';
+export interface ExtendedAuthResponseContext extends AuthResponseContext {
+    userData: any;
+    userDataJSON: string;
+    srcData: string;
+}

package/dist/types/http/route/route-mapping.d.ts

@@ -0,0 +1,12 @@
+import { RouteValidatorConfig } from './route-validator-config';
+import { HandlerFunction } from '../../config/http/handler-function';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config';
+export interface RouteMapping {
+    method: string;
+    path: string;
+    function: HandlerFunction<any>;
+    metaProcessingConfig: HttpProcessingConfig;
+    validation: RouteValidatorConfig;
+    outboundValidation: RouteValidatorConfig;
+    authorizerName: string;
+}

package/dist/types/http/route/route-validator-config.d.ts

@@ -0,0 +1,5 @@
+export interface RouteValidatorConfig {
+    modelName: string;
+    emptyAllowed: boolean;
+    extraPropertiesAllowed: boolean;
+}

package/dist/types/http/route/router-util.d.ts

@@ -0,0 +1,26 @@
+import { EpsilonRouter } from './epsilon-router';
+import { OpenApiDocument } from '../../config/open-api/open-api-document';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundHttpAdapterHandler } from '../../background/background-http-adapter-handler';
+import { HttpConfig } from '../../config/http/http-config';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config';
+import { WebTokenManipulator } from '../auth/web-token-manipulator';
+import { FilterFunction } from '../../config/http/filter-function';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+/**
+ * Endpoints about the api itself
+ */
+export declare class RouterUtil {
+    private constructor();
+    static defaultAuthenticationHeaderParsingEpsilonPreFilters(webTokenManipulator: WebTokenManipulator<JwtTokenBase>): FilterFunction[];
+    static defaultEpsilonPreFilters(): FilterFunction[];
+    static defaultEpsilonPostFilters(): FilterFunction[];
+    static defaultEpsilonErrorFilters(): FilterFunction[];
+    static defaultHttpMetaProcessingConfigWithAuthenticationHeaderParsing(webTokenManipulator: WebTokenManipulator<JwtTokenBase>): HttpProcessingConfig;
+    static defaultHttpMetaProcessingConfig(): HttpProcessingConfig;
+    static assignDefaultsOnHttpConfig(cfg: HttpConfig): HttpConfig;
+    static findApplicableMeta(httpConfig: HttpConfig, method: string, path: string): HttpProcessingConfig;
+    static openApiYamlToRouterConfig(httpConfig: HttpConfig, openApiDoc: OpenApiDocument, modelValidator: ModelValidator, backgroundHttpAdapterHandler: BackgroundHttpAdapterHandler): EpsilonRouter;
+    private static findAndValidateModelName;
+    static openApiPathToRouteParserPath(input: string): string;
+}

package/dist/types/http/web-handler.d.ts

@@ -0,0 +1,26 @@
+import { EpsilonRouter } from './route/epsilon-router';
+import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
+import Route from 'route-parser';
+import { RouteMapping } from './route/route-mapping';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+/**
+ * This class functions as the adapter from a default lambda function to the handlers exposed via Epsilon
+ */
+export declare class WebHandler implements EpsilonLambdaEventHandler<APIGatewayEvent> {
+    private routerConfig;
+    static readonly MAXIMUM_LAMBDA_BODY_SIZE_BYTES: number;
+    constructor(routerConfig: EpsilonRouter);
+    get router(): EpsilonRouter;
+    extractLabel(evt: APIGatewayEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(event: APIGatewayEvent, context: Context): Promise<ProxyResult>;
+    openApiLambdaHandler(evt: ExtendedAPIGatewayEvent, context: Context): Promise<ProxyResult>;
+    findBestMatchingRoute(event: APIGatewayEvent): RouteAndParse;
+    private cleanPath;
+}
+export interface RouteAndParse {
+    mapping: RouteMapping;
+    route: Route;
+    parsed: any;
+}

package/dist/types/http/web-v2-handler.d.ts

@@ -0,0 +1,13 @@
+import { APIGatewayProxyEventV2, Context, ProxyResult } from 'aws-lambda';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { WebHandler } from './web-handler';
+/**
+ * This class functions as the adapter from a default lambda function to the handlers exposed via Epsilon
+ */
+export declare class WebV2Handler implements EpsilonLambdaEventHandler<APIGatewayProxyEventV2> {
+    private webHandler;
+    constructor(webHandler: WebHandler);
+    extractLabel(evt: APIGatewayProxyEventV2, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: APIGatewayProxyEventV2, context: Context): Promise<ProxyResult>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,136 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export * from './epsilon-build-properties';
+export * from './epsilon-constants';
+export * from './epsilon-global-handler';
+export * from './epsilon-instance';
+export * from './epsilon-logging-extension-processor';
+export * from './inter-api-manager';
+export * from './local-container-server';
+export * from './local-server-cert';
+export * from './local-server';
+export * from './run-background-process-from-command-line';
+export * from './test-error-server';
+export * from './background/background-dynamo-log-table-handler';
+export * from './background/background-entry';
+export * from './background/background-execution-event-type';
+export * from './background/background-execution-event';
+export * from './background/background-execution-listener';
+export * from './background/background-handler';
+export * from './background/background-http-adapter-handler';
+export * from './background/background-meta-response-internal';
+export * from './background/background-process-handling';
+export * from './background/background-process-log-table-entry';
+export * from './background/background-queue-response-internal';
+export * from './background/background-validator';
+export * from './background/epsilon-background-process-error';
+export * from './background/internal-background-entry';
+export * from './background/s3-background-transaction-logger';
+export * from './background/manager/abstract-background-manager';
+export * from './background/manager/aws-sqs-sns-background-manager';
+export * from './background/manager/background-manager-like';
+export * from './background/manager/single-thread-local-background-manager';
+export * from './build/ratchet-epsilon-common-info';
+export * from './built-in/built-in-trace-id-generators';
+export * from './built-in/background/echo-processor';
+export * from './built-in/background/log-and-enqueue-echo-processor';
+export * from './built-in/background/log-message-background-error-processor';
+export * from './built-in/background/no-op-processor';
+export * from './built-in/background/retry-processor';
+export * from './built-in/background/sample-delay-processor';
+export * from './built-in/background/sample-input-validated-processor-data';
+export * from './built-in/background/sample-input-validated-processor';
+export * from './built-in/daemon/daemon-authorizer-function';
+export * from './built-in/daemon/daemon-config';
+export * from './built-in/daemon/daemon-group-selection-function';
+export * from './built-in/daemon/daemon-handler';
+export * from './built-in/daemon/daemon-process-state-list';
+export * from './built-in/http/apollo-filter';
+export * from './built-in/http/built-in-auth-filters';
+export * from './built-in/http/built-in-authorizers';
+export * from './built-in/http/built-in-filters';
+export * from './built-in/http/built-in-handlers';
+export * from './built-in/http/log-level-manipulation-filter';
+export * from './built-in/http/run-handler-as-filter';
+export * from './cli-bootstrap/epsilon-run-background-process-from-command-line-dry-run';
+export * from './config/dynamo-db-config';
+export * from './config/epsilon-config';
+export * from './config/epsilon-lambda-event-handler';
+export * from './config/epsilon-logger-config';
+export * from './config/generic-aws-event-handler-function';
+export * from './config/logging-trace-id-generator';
+export * from './config/s3-config';
+export * from './config/sns-config';
+export * from './config/background/background-aws-config';
+export * from './config/background/background-config';
+export * from './config/background/background-error-processor';
+export * from './config/background/background-processor';
+export * from './config/background/background-transaction-log';
+export * from './config/background/background-transaction-logger';
+export * from './config/cron/abstract-cron-entry';
+export * from './config/cron/cron-background-entry';
+export * from './config/cron/cron-config';
+export * from './config/http/authorizer-function';
+export * from './config/http/epsilon-authorization-context';
+export * from './config/http/extended-api-gateway-event';
+export * from './config/http/filter-chain-context';
+export * from './config/http/filter-function';
+export * from './config/http/handler-function';
+export * from './config/http/http-config';
+export * from './config/http/http-processing-config';
+export * from './config/http/mapped-http-processing-config';
+export * from './config/http/null-returned-object-handling';
+export * from './config/inter-api/inter-api-aws-config';
+export * from './config/inter-api/inter-api-config';
+export * from './config/inter-api/inter-api-process-mapping';
+export * from './config/open-api/open-api-document-components';
+export * from './config/open-api/open-api-document-path';
+export * from './config/open-api/open-api-document';
+export * from './http/event-util';
+export * from './http/response-util';
+export * from './http/web-handler';
+export * from './http/web-v2-handler';
+export * from './http/auth/api-gateway-adapter-authentication-handler';
+export * from './http/auth/auth0-web-token-manipulator';
+export * from './http/auth/basic-auth-token';
+export * from './http/auth/google-web-token-manipulator';
+export * from './http/auth/jwt-ratchet-local-web-token-manipulator';
+export * from './http/auth/local-web-token-manipulator';
+export * from './http/auth/web-token-manipulator';
+export * from './http/error/bad-gateway';
+export * from './http/error/bad-request-error';
+export * from './http/error/conflict-error';
+export * from './http/error/epsilon-http-error';
+export * from './http/error/forbidden-error';
+export * from './http/error/gateway-timeout';
+export * from './http/error/method-not-allowed-error';
+export * from './http/error/misconfigured-error';
+export * from './http/error/not-found-error';
+export * from './http/error/not-implemented';
+export * from './http/error/request-timeout-error';
+export * from './http/error/service-unavailable';
+export * from './http/error/too-many-requests-error';
+export * from './http/error/unauthorized-error';
+export * from './http/route/epsilon-router';
+export * from './http/route/extended-auth-response-context';
+export * from './http/route/route-mapping';
+export * from './http/route/route-validator-config';
+export * from './http/route/router-util';
+export * from './inter-api/inter-api-entry';
+export * from './inter-api/inter-api-util';
+export * from './lambda-event-handler/cron-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/dynamo-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/generic-sns-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/inter-api-epsilon-lambda-event-handler';
+export * from './lambda-event-handler/s3-epsilon-lambda-event-handler';
+export * from './open-api-util/open-api-doc-modifications';
+export * from './open-api-util/open-api-doc-modifier';
+export * from './open-api-util/yaml-combiner';
+export * from './sample/sample-batch-only-local-server';
+export * from './sample/sample-local-server';
+export * from './sample/sample-server-components';
+export * from './util/aws-util';
+export * from './util/context-util';
+export * from './util/cron-util';
+export * from './util/epsilon-config-parser';

package/dist/types/inter-api/inter-api-entry.d.ts

@@ -0,0 +1,7 @@
+export interface InterApiEntry<T> {
+    source: string;
+    type: string;
+    data: T;
+    traceId?: string;
+    traceDepth?: number;
+}

package/dist/types/inter-api/inter-api-util.d.ts

@@ -0,0 +1,10 @@
+import { SNSEvent } from 'aws-lambda';
+import { InterApiEntry } from './inter-api-entry';
+import { InterApiConfig } from '../config/inter-api/inter-api-config';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like';
+export declare class InterApiUtil {
+    static isInterApiSnsEvent(event: any): boolean;
+    static extractEntryFromEvent(evt: SNSEvent): InterApiEntry<any>;
+    static processInterApiEvent(evt: SNSEvent, cfg: InterApiConfig, mgr: BackgroundManagerLike): Promise<string[]>;
+    static addTraceToInterApiEntry(ent: InterApiEntry<any>): InterApiEntry<any>;
+}

package/dist/types/inter-api-manager.d.ts

@@ -0,0 +1,17 @@
+import { InterApiEntry } from './inter-api/inter-api-entry';
+import { InterApiAwsConfig } from './config/inter-api/inter-api-aws-config';
+import { SNSClient } from '@aws-sdk/client-sns';
+/**
+ * Handles all submission of events to the inter-api SNS topic (if any)
+ */
+export declare class InterApiManager {
+    private _aws;
+    private _sns;
+    constructor(_aws: InterApiAwsConfig, _sns: SNSClient);
+    get config(): InterApiAwsConfig;
+    get sns(): SNSClient;
+    createEntry<T>(type: string, data?: T): InterApiEntry<T>;
+    fireInterApiEventByParts<T>(type: string, data?: T): Promise<string>;
+    fireInterApiEvent<T>(entry: InterApiEntry<T>): Promise<string>;
+    writeMessageToSnsTopic(message: string): Promise<string>;
+}

package/dist/types/lambda-event-handler/cron-epsilon-lambda-event-handler.d.ts

@@ -0,0 +1,14 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { Context, ProxyResult, ScheduledEvent } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance';
+import { CronConfig } from '../config/cron/cron-config';
+import { BackgroundHandler } from '../background/background-handler';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like';
+export declare class CronEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<ScheduledEvent> {
+    private _epsilon;
+    constructor(_epsilon: EpsilonInstance);
+    extractLabel(evt: ScheduledEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: ScheduledEvent, context: Context): Promise<ProxyResult>;
+    static processCronEvent(evt: ScheduledEvent, cronConfig: CronConfig, backgroundManager: BackgroundManagerLike, background: BackgroundHandler): Promise<boolean>;
+}

package/dist/types/lambda-event-handler/dynamo-epsilon-lambda-event-handler.d.ts

@@ -0,0 +1,11 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { Context, DynamoDBStreamEvent, ProxyResult } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance';
+export declare class DynamoEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<DynamoDBStreamEvent> {
+    private _epsilon;
+    constructor(_epsilon: EpsilonInstance);
+    extractLabel(evt: DynamoDBStreamEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: DynamoDBStreamEvent, context: Context): Promise<ProxyResult>;
+    processUncaughtError(event: DynamoDBStreamEvent, context: Context, err: any): Promise<ProxyResult>;
+}

package/dist/types/lambda-event-handler/generic-sns-epsilon-lambda-event-handler.d.ts

@@ -0,0 +1,10 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { Context, ProxyResult, SNSEvent } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance';
+export declare class GenericSnsEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<SNSEvent> {
+    private _epsilon;
+    constructor(_epsilon: EpsilonInstance);
+    extractLabel(evt: SNSEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: SNSEvent, context: Context): Promise<ProxyResult>;
+}

package/dist/types/lambda-event-handler/inter-api-epsilon-lambda-event-handler.d.ts

@@ -0,0 +1,10 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { Context, ProxyResult, SNSEvent } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance';
+export declare class InterApiEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<SNSEvent> {
+    private _epsilon;
+    constructor(_epsilon: EpsilonInstance);
+    extractLabel(evt: SNSEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: SNSEvent, context: Context): Promise<ProxyResult>;
+}

package/dist/types/lambda-event-handler/s3-epsilon-lambda-event-handler.d.ts

@@ -0,0 +1,10 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { Context, ProxyResult, S3Event } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance';
+export declare class S3EpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<S3Event> {
+    private _epsilon;
+    constructor(_epsilon: EpsilonInstance);
+    extractLabel(evt: S3Event, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: S3Event, context: Context): Promise<ProxyResult>;
+}

package/dist/types/local-container-server.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+/**
+ * A simplistic server for testing your lambdas locally
+ */
+export declare class LocalContainerServer {
+    private port;
+    private server;
+    private aborted;
+    constructor(port?: number);
+    runServer(): Promise<boolean>;
+    requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any>;
+}

package/dist/types/local-server-cert.d.ts

@@ -0,0 +1,5 @@
+export declare class LocalServerCert {
+    static readonly CLIENT_CSR: string;
+    static readonly CLIENT_CERT_PEM: string;
+    static readonly CLIENT_KEY_PEM: string;
+}

package/dist/types/local-server.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
+import { IncomingMessage, ServerResponse } from 'http';
+import { EpsilonGlobalHandler } from './epsilon-global-handler';
+/**
+ * A simplistic server for testing your lambdas locally
+ */
+export declare class LocalServer {
+    private globalHandler;
+    private port;
+    private server;
+    private aborted;
+    constructor(globalHandler: EpsilonGlobalHandler, port?: number, https?: boolean);
+    runServer(): Promise<boolean>;
+    requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any>;
+    static bodyAsBase64String(request: IncomingMessage): Promise<string>;
+    static messageToApiGatewayEvent(request: IncomingMessage, context: Context): Promise<APIGatewayEvent>;
+    static writeProxyResultToServerResponse(proxyResult: ProxyResult, response: ServerResponse): Promise<boolean>;
+}

package/dist/types/open-api-util/open-api-doc-modifications.d.ts

@@ -0,0 +1,8 @@
+export interface OpenApiDocModifications {
+    newServerPath: string;
+    removeEndpoints: RegExp[];
+    removeTags: string[];
+    removeSchemas: string[];
+    sortEndpoints: boolean;
+    sortSchemas: boolean;
+}

package/dist/types/open-api-util/open-api-doc-modifier.d.ts

@@ -0,0 +1,10 @@
+import { OpenApiDocModifications } from './open-api-doc-modifications';
+/**
+ * Monitoring endpoints
+ */
+export declare class OpenApiDocModifier {
+    private options;
+    constructor(options: OpenApiDocModifications);
+    modifyOpenApiDoc(yamlString: string): string;
+    private matchNone;
+}

package/dist/types/open-api-util/yaml-combiner.d.ts

@@ -0,0 +1,3 @@
+export declare class YamlCombiner {
+    static combine(files: string[], inRootPath?: string[]): string;
+}

package/dist/types/run-background-process-from-command-line.d.ts

@@ -0,0 +1,13 @@
+import { EpsilonGlobalHandler } from './epsilon-global-handler';
+/**
+ * IMPORTANT NOTE
+ * This file is part of the bootstrapper to bridge from the Epsilon Background processor
+ * to the AWS Batch processing Docker setup.
+ *
+ * DO NOT MESS WITH IT UNLESS YOU REALLY KNOW WHAT YOU ARE DOING.
+ *
+ * You are likely to mess it up otherwise.
+ */
+export declare class RunBackgroundProcessFromCommandLine {
+    static processBackgroundCliRequest(epsilon: EpsilonGlobalHandler, dryRun?: boolean): Promise<boolean>;
+}

package/dist/types/sample/sample-batch-only-local-server.d.ts

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

package/dist/types/sample/sample-local-server.d.ts

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

package/dist/types/sample/sample-server-components.d.ts

@@ -0,0 +1,12 @@
+import { ApolloServer } from 'apollo-server-lambda';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler';
+import { EpsilonConfig } from '../config/epsilon-config';
+export declare class SampleServerComponents {
+    private constructor();
+    static createSampleApollo(): Promise<ApolloServer>;
+    static createSampleEpsilonConfig(): Promise<EpsilonConfig>;
+    static createSampleEpsilonGlobalHandler(): Promise<EpsilonGlobalHandler>;
+    static createSampleBatchOnlyEpsilonGlobalHandler(): Promise<EpsilonGlobalHandler>;
+    static loadSampleOpenApiYaml(): string;
+    static loadSampleServerGQL(): string;
+}

package/dist/types/test-error-server.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+/**
+ * A simplistic server for testing your lambdas locally
+ */
+export declare class TestErrorServer {
+    private port;
+    private server;
+    private aborted;
+    constructor(port?: number);
+    runServer(): Promise<boolean>;
+    requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any>;
+}

package/dist/types/util/aws-util.d.ts

@@ -0,0 +1,8 @@
+import { APIGatewayEvent, APIGatewayEventRequestContextV2, APIGatewayEventRequestContextWithAuthorizer, APIGatewayProxyEventV2 } from 'aws-lambda';
+export declare class AwsUtil {
+    static apiGatewayV2ToApiGatewayV1(srcEvt: APIGatewayProxyEventV2): APIGatewayEvent;
+    static apiGatewayV2RequestContextToApiGatewayV1RequestContext(srcEvt: APIGatewayEventRequestContextV2): APIGatewayEventRequestContextWithAuthorizer<any>;
+    static findInMap<T>(toFind: string, map: Map<string, T>): T;
+    static matchExact(r: any, str: any): boolean;
+    static resolvePotentialFunctionToResult<T>(src: any, def: T): T;
+}

package/dist/types/util/context-util.d.ts

@@ -0,0 +1,33 @@
+import { Context, ProxyResult } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance';
+import { InternalBackgroundEntry } from '../background/internal-background-entry';
+import { InterApiEntry } from '../inter-api/inter-api-entry';
+export declare class ContextUtil {
+    private static CURRENT_EPSILON_REFERENCE;
+    private static CURRENT_CONTEXT;
+    private static CURRENT_EVENT;
+    private static CURRENT_LOG_VARS;
+    private static CURRENT_PROCESS_LABEL;
+    private static CURRENT_OVERRIDE_TRACE_ID;
+    private static CURRENT_OVERRIDE_TRACE_DEPTH;
+    private constructor();
+    static initContext(epsilon: EpsilonInstance, evt: any, ctx: Context, processLabel: string): void;
+    static clearContext(): void;
+    static setOverrideTrace(traceId: string, traceDepth: number): void;
+    static setOverrideTraceFromInternalBackgroundEntry(entry: InternalBackgroundEntry<any>): void;
+    static setOverrideTraceFromInterApiEntry(interApiEntry: InterApiEntry<any>): void;
+    static addHeadersToRecord(input: Record<string, any>, depthOffset?: number): void;
+    static addTraceToProxyResult(pr: ProxyResult): void;
+    static addTraceToHttpRequestInit(ri: RequestInit): void;
+    static setProcessLabel(processLabel: string): void;
+    static currentRequestId(): string;
+    static remainingTimeMS(): number;
+    static currentProcessLabel(): string;
+    private static traceHeaderName;
+    private static traceDepthHeaderName;
+    static currentTraceId(): string;
+    static currentTraceDepth(): number;
+    static addLogVariable(name: string, val: string | number | boolean): void;
+    static fetchLogVariable(name: string): string | number | boolean;
+    static fetchLogVariables(): Record<string, string | number | boolean>;
+}

package/dist/types/util/cron-util.d.ts

@@ -0,0 +1,11 @@
+import { ScheduledEvent } from 'aws-lambda';
+import { AbstractCronEntry } from '../config/cron/abstract-cron-entry';
+import { CronConfig } from '../config/cron/cron-config';
+export declare class CronUtil {
+    static everyNMinuteFilter(n: number): number[];
+    static everyNDaysOfYearFilter(n: number): number[];
+    static everyNElementFilter(n: number, m: number): number[];
+    static numberMatchesFilter(num: number, filter: number[]): boolean;
+    static eventMatchesEntry(event: ScheduledEvent, entry: AbstractCronEntry, cfg: CronConfig, testTimeEpochMS?: number): boolean;
+    static cronEntryName(entry: AbstractCronEntry, idx?: number): string;
+}

package/dist/types/util/epsilon-config-parser.d.ts

@@ -0,0 +1,14 @@
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { OpenApiDocument } from '../config/open-api/open-api-document';
+import { EpsilonConfig } from '../config/epsilon-config';
+import { EpsilonInstance } from '../epsilon-instance';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like';
+export declare class EpsilonConfigParser {
+    constructor();
+    static epsilonConfigToEpsilonGlobalHandler(config: EpsilonConfig, backgroundManager?: BackgroundManagerLike): EpsilonGlobalHandler;
+    static epsilonConfigToEpsilonInstance(config: EpsilonConfig, backgroundManager?: BackgroundManagerLike): EpsilonInstance;
+    static parseOpenApiDocument(yamlString: string): OpenApiDocument;
+    static openApiDocToValidator(doc: OpenApiDocument): ModelValidator;
+    static validateGlobalConfig(config: EpsilonConfig): void;
+}