@bitblit/ratchet-epsilon-common 4.0.183-alpha → 4.0.185-alpha

package/lib/config/background/background-error-processor.d.ts

@@ -0,0 +1,4 @@
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
+export interface BackgroundErrorProcessor {
+    handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void>;
+}

package/lib/config/background/background-processor.d.ts

@@ -0,0 +1,6 @@
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export interface BackgroundProcessor<T> {
+    typeName: string;
+    dataSchemaName?: string;
+    handleEvent(data: T, mgr: BackgroundManagerLike): Promise<any>;
+}

package/lib/config/background/background-transaction-log.d.ts

@@ -0,0 +1,8 @@
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
+export interface BackgroundTransactionLog {
+    request: InternalBackgroundEntry<any>;
+    running: boolean;
+    runtimeMS?: number;
+    result?: any;
+    error?: any;
+}

package/lib/config/background/background-transaction-logger.d.ts

@@ -0,0 +1,5 @@
+import { BackgroundTransactionLog } from './background-transaction-log.js';
+export interface BackgroundTransactionLogger {
+    logTransaction(txLog: BackgroundTransactionLog): Promise<void>;
+    readTransactionLog(txGuid: string): Promise<BackgroundTransactionLog>;
+}

package/lib/config/cron/abstract-cron-entry.d.ts

@@ -0,0 +1,12 @@
+export interface AbstractCronEntry {
+    name?: string;
+    eventFilter?: RegExp;
+    minuteFilter?: number[];
+    hourFilter?: number[];
+    dayOfWeekFilter?: number[];
+    dayOfMonthFilter?: number[];
+    monthOfYearFilter?: number[];
+    contextMatchFilter?: RegExp;
+    contextNoMatchFilter?: RegExp;
+    overrideTimezone?: string;
+}

package/lib/config/cron/cron-background-entry.d.ts

@@ -0,0 +1,6 @@
+import { AbstractCronEntry } from './abstract-cron-entry.js';
+export interface CronBackgroundEntry extends AbstractCronEntry {
+    backgroundTaskType: string;
+    fireImmediate: boolean;
+    data?: any;
+}

package/lib/config/cron/cron-config.d.ts

@@ -0,0 +1,6 @@
+import { CronBackgroundEntry } from './cron-background-entry.js';
+export interface CronConfig {
+    timezone: string;
+    context: string;
+    entries: CronBackgroundEntry[];
+}

package/lib/config/dynamo-db-config.d.ts

@@ -0,0 +1,5 @@
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
+import { DynamoDBStreamEvent } from 'aws-lambda';
+export interface DynamoDbConfig {
+    handlers: Map<string, GenericAwsEventHandlerFunction<DynamoDBStreamEvent>>;
+}

package/lib/config/epsilon-config.d.ts

@@ -0,0 +1,21 @@
+import { HttpConfig } from './http/http-config.js';
+import { BackgroundConfig } from './background/background-config.js';
+import { CronConfig } from './cron/cron-config.js';
+import { DynamoDbConfig } from './dynamo-db-config.js';
+import { S3Config } from './s3-config.js';
+import { SnsConfig } from './sns-config.js';
+import { EpsilonLoggerConfig } from './epsilon-logger-config.js';
+import { InterApiConfig } from './inter-api/inter-api-config.js';
+export interface EpsilonConfig {
+    label?: string;
+    disableLastResortTimeout?: boolean;
+    openApiYamlString: string;
+    httpConfig?: HttpConfig;
+    backgroundConfig?: BackgroundConfig;
+    interApiConfig?: InterApiConfig;
+    cron?: CronConfig;
+    dynamoDb?: DynamoDbConfig;
+    s3?: S3Config;
+    sns?: SnsConfig;
+    loggerConfig?: EpsilonLoggerConfig;
+}

package/lib/config/epsilon-lambda-event-handler.d.ts

@@ -0,0 +1,7 @@
+import { Context, ProxyResult } from 'aws-lambda';
+export interface EpsilonLambdaEventHandler<T> {
+    handlesEvent(evt: any): boolean;
+    extractLabel(evt: T, context: Context): string;
+    processEvent(evt: T, context: Context): Promise<ProxyResult>;
+    processUncaughtError?(evt: T, context: Context, err: Error): Promise<ProxyResult>;
+}

package/lib/config/epsilon-logger-config.d.ts

@@ -0,0 +1,13 @@
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { LogMessageFormatType } from '@bitblit/ratchet-common';
+import { LoggingTraceIdGenerator } from './logging-trace-id-generator.js';
+export interface EpsilonLoggerConfig {
+    envParamLogLevelName?: string;
+    queryParamLogLevelName?: string;
+    queryParamTracePrefixName?: string;
+    traceIdGenerator?: LoggingTraceIdGenerator;
+    logMessageFormatType?: LogMessageFormatType;
+    traceHeaderName?: string;
+    traceDepthHeaderName?: string;
+    epsilonStartEndMessageLogLevel?: LoggerLevelName;
+}

package/lib/config/generic-aws-event-handler-function.d.ts

@@ -0,0 +1,3 @@
+export interface GenericAwsEventHandlerFunction<T> {
+    (event: T): Promise<void>;
+}

package/lib/config/http/authorizer-function.d.ts

@@ -0,0 +1,6 @@
+import { RouteMapping } from '../../http/route/route-mapping.js';
+import { EpsilonAuthorizationContext } from './epsilon-authorization-context.js';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+export interface AuthorizerFunction {
+    (authData: EpsilonAuthorizationContext<any>, event?: ExtendedAPIGatewayEvent, route?: RouteMapping): Promise<boolean>;
+}

package/lib/config/http/epsilon-authorization-context.d.ts

@@ -0,0 +1,5 @@
+export interface EpsilonAuthorizationContext<T> {
+    raw: string;
+    auth: T;
+    error: string;
+}

package/lib/config/http/extended-api-gateway-event.d.ts

@@ -0,0 +1,7 @@
+import { APIGatewayEvent } from 'aws-lambda';
+import { EpsilonAuthorizationContext } from './epsilon-authorization-context.js';
+export interface ExtendedAPIGatewayEvent extends APIGatewayEvent {
+    parsedBody: any;
+    authorization: EpsilonAuthorizationContext<any>;
+    convertedFromV2Event: boolean;
+}

package/lib/config/http/filter-chain-context.d.ts

@@ -0,0 +1,14 @@
+import { Context, ProxyResult } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+import { RouteAndParse } from '../../http/web-handler.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { AuthorizerFunction } from './authorizer-function.js';
+export interface FilterChainContext {
+    event: ExtendedAPIGatewayEvent;
+    context: Context;
+    rawResult: any;
+    result: ProxyResult;
+    routeAndParse: RouteAndParse;
+    modelValidator: ModelValidator;
+    authenticators: Map<string, AuthorizerFunction>;
+}

package/lib/config/http/filter-function.d.ts

@@ -0,0 +1,4 @@
+import { FilterChainContext } from './filter-chain-context.js';
+export interface FilterFunction {
+    (fCtx: FilterChainContext): Promise<boolean>;
+}

package/lib/config/http/handler-function.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from './extended-api-gateway-event.js';
+export interface HandlerFunction<T> {
+    (event: ExtendedAPIGatewayEvent, context?: Context): Promise<T>;
+}

package/lib/config/http/http-config.d.ts

@@ -0,0 +1,15 @@
+import { HandlerFunction } from './handler-function.js';
+import { AuthorizerFunction } from './authorizer-function.js';
+import { HttpProcessingConfig } from './http-processing-config.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { MappedHttpProcessingConfig } from './mapped-http-processing-config.js';
+export interface HttpConfig {
+    defaultMetaHandling: HttpProcessingConfig;
+    overrideMetaHandling?: MappedHttpProcessingConfig[];
+    handlers: Map<string, HandlerFunction<any>>;
+    authorizers?: Map<string, AuthorizerFunction>;
+    staticContentRoutes?: Record<string, string>;
+    prefixesToStripBeforeRouteMatch?: string[];
+    overrideModelValidator?: ModelValidator;
+    filterHandledRouteMatches?: string[];
+}

package/lib/config/http/http-processing-config.d.ts

@@ -0,0 +1,11 @@
+import { NullReturnedObjectHandling } from './null-returned-object-handling.js';
+import { FilterFunction } from './filter-function.js';
+export interface HttpProcessingConfig {
+    configName?: string;
+    timeoutMS: number;
+    overrideAuthorizerName?: string;
+    preFilters?: FilterFunction[];
+    postFilters?: FilterFunction[];
+    errorFilters?: FilterFunction[];
+    nullReturnedObjectHandling?: NullReturnedObjectHandling;
+}

package/lib/config/http/mapped-http-processing-config.d.ts

@@ -0,0 +1,7 @@
+import { HttpProcessingConfig } from './http-processing-config.js';
+export interface MappedHttpProcessingConfig {
+    methods?: string[];
+    pathRegex: string;
+    invertPathMatching?: boolean;
+    config: HttpProcessingConfig;
+}

package/lib/config/http/null-returned-object-handling.d.ts

@@ -0,0 +1,5 @@
+export declare enum NullReturnedObjectHandling {
+    Error = "Error",
+    ConvertToEmptyString = "ConvertToEmptyString",
+    Return404NotFoundResponse = "Return404NotFoundResponse"
+}

package/lib/config/inter-api/inter-api-aws-config.d.ts

@@ -0,0 +1,5 @@
+export interface InterApiAwsConfig {
+    localMode: boolean;
+    source: string;
+    snsArn: string;
+}

package/lib/config/inter-api/inter-api-config.d.ts

@@ -0,0 +1,6 @@
+import { InterApiAwsConfig } from './inter-api-aws-config.js';
+import { InterApiProcessMapping } from './inter-api-process-mapping.js';
+export interface InterApiConfig {
+    aws: InterApiAwsConfig;
+    processMappings: InterApiProcessMapping[];
+}

package/lib/config/inter-api/inter-api-process-mapping.d.ts

@@ -0,0 +1,6 @@
+export interface InterApiProcessMapping {
+    sourceRegex: string;
+    typeRegex: string;
+    disabled: boolean;
+    backgroundProcessTypes: string[];
+}

package/lib/config/logging-trace-id-generator.d.ts

@@ -0,0 +1,4 @@
+import { Context } from 'aws-lambda';
+export interface LoggingTraceIdGenerator {
+    (event?: any, context?: Context): string;
+}

package/lib/config/open-api/open-api-document-components.d.ts

@@ -0,0 +1,4 @@
+export interface OpenApiDocumentComponents {
+    securitySchemes: any[];
+    schemas: any[];
+}

package/lib/config/open-api/open-api-document-path.d.ts

@@ -0,0 +1,2 @@
+export interface OpenApiDocumentPath {
+}

package/lib/config/open-api/open-api-document.d.ts

@@ -0,0 +1,6 @@
+import { OpenApiDocumentComponents } from './open-api-document-components.js';
+import { OpenApiDocumentPath } from './open-api-document-path.js';
+export interface OpenApiDocument {
+    components: OpenApiDocumentComponents;
+    paths: OpenApiDocumentPath[];
+}

package/lib/config/s3-config.d.ts

@@ -0,0 +1,6 @@
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
+import { S3Event } from 'aws-lambda';
+export interface S3Config {
+    createHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;
+    removeHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;
+}

package/lib/config/sns-config.d.ts

@@ -0,0 +1,5 @@
+import { GenericAwsEventHandlerFunction } from './generic-aws-event-handler-function.js';
+import { SNSEvent } from 'aws-lambda';
+export interface SnsConfig {
+    handlers: Map<string, GenericAwsEventHandlerFunction<SNSEvent>>;
+}

package/lib/epsilon-global-handler.d.ts

@@ -1,7 +1,7 @@
 import { Context, ProxyResult } from 'aws-lambda';
+import { LoggerOptions } from '@bitblit/ratchet-common';
 import { BackgroundEntry } from './background/background-entry.js';
 import { EpsilonInstance } from './epsilon-instance.js';
-import { LoggerOptions } from '@bitblit/ratchet-common';
 export declare class EpsilonGlobalHandler {
     private _epsilon;
     private static LOGGER_CONFIGURED;

package/lib/http/auth/api-gateway-adapter-authentication-handler.d.ts

@@ -0,0 +1,8 @@
+import { Callback, Context, CustomAuthorizerEvent } from 'aws-lambda';
+export declare class ApiGatewayAdapterAuthenticationHandler {
+    private webTokenManipulator;
+    constructor(issuer: string, encryptionKeys: string);
+    lambdaHandler(event: CustomAuthorizerEvent, context: Context, callback: Callback): void;
+    private createPolicy;
+    static extractTokenStringFromAuthorizerEvent(event: CustomAuthorizerEvent): string;
+}

package/lib/http/auth/auth0-web-token-manipulator.d.ts

@@ -0,0 +1,13 @@
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { WebTokenManipulator } from './web-token-manipulator.js';
+export declare class Auth0WebTokenManipulator implements WebTokenManipulator<JwtTokenBase> {
+    private clientId;
+    private jwksUri;
+    private issuer;
+    private jwksClient;
+    constructor(clientId: string, jwksUri: string, issuer: string);
+    extractTokenFromAuthorizationHeader<T>(authHeader: string): Promise<JwtTokenBase>;
+    parseAndValidateAuth0Token<T>(auth0Token: string, allowExpired?: boolean): Promise<JwtTokenBase>;
+    private fetchSigningKey;
+    private fetchJwksClient;
+}

package/lib/http/auth/basic-auth-token.d.ts

@@ -0,0 +1,4 @@
+export interface BasicAuthToken {
+    username: string;
+    password: string;
+}

package/lib/http/auth/google-web-token-manipulator.d.ts

@@ -0,0 +1,14 @@
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export declare class GoogleWebTokenManipulator implements WebTokenManipulator<JwtTokenBase> {
+    private clientId;
+    private static readonly GOOGLE_DISCOVERY_DOCUMENT;
+    private cacheGoogleDiscoveryDocument;
+    private jwksClient;
+    constructor(clientId: string);
+    extractTokenFromAuthorizationHeader<T extends JwtTokenBase>(authHeader: string): Promise<JwtTokenBase>;
+    parseAndValidateGoogleToken<T extends JwtTokenBase>(googleToken: string, allowExpired?: boolean): Promise<JwtTokenBase>;
+    private fetchSigningKey;
+    private fetchJwksClient;
+    private fetchGoogleDiscoveryDocument;
+}

package/lib/http/auth/google-web-token-manipulator.spec.d.ts

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

package/lib/http/auth/jwt-ratchet-local-web-token-manipulator.d.ts

@@ -0,0 +1,11 @@
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { JwtRatchetLike } from '@bitblit/ratchet-common';
+export declare class JwtRatchetLocalWebTokenManipulator<T extends JwtTokenBase> implements WebTokenManipulator<T> {
+    private _jwtRatchet;
+    private _issuer;
+    constructor(_jwtRatchet: JwtRatchetLike, _issuer: string);
+    get jwtRatchet(): JwtRatchetLike;
+    get issuer(): string;
+    extractTokenFromAuthorizationHeader<T>(header: string): Promise<T>;
+}

package/lib/http/auth/local-web-token-manipulator.d.ts

@@ -0,0 +1,19 @@
+import { WebTokenManipulator } from './web-token-manipulator.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { JwtRatchet } from '@bitblit/ratchet-common';
+export declare class LocalWebTokenManipulator<T extends JwtTokenBase> implements WebTokenManipulator<T> {
+    private encryptionKeys;
+    private issuer;
+    private _ratchet;
+    constructor(encryptionKeys: string[], issuer: string);
+    withExtraDecryptionKeys(keys: string[]): LocalWebTokenManipulator<T>;
+    withParseFailureLogLevel(logLevel: LoggerLevelName): LocalWebTokenManipulator<T>;
+    withOldKeyUseLogLevel(logLevel: LoggerLevelName): LocalWebTokenManipulator<T>;
+    get jwtRatchet(): JwtRatchet;
+    get selectRandomEncryptionKey(): Promise<string>;
+    createRefreshedJWTString(tokenString: string, expirationSeconds: number, allowExpired?: boolean): Promise<string>;
+    parseAndValidateJWTStringAsync<T extends JwtTokenBase>(tokenString: string): Promise<T>;
+    createJWTStringAsync<T>(principal: string, userObject: T, roles?: string[], expirationSeconds?: number, proxyUser?: T): Promise<string>;
+    extractTokenFromAuthorizationHeader<T extends JwtTokenBase>(header: string): Promise<T>;
+}

package/lib/http/auth/local-web-token-manipulator.spec.d.ts

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

package/lib/http/auth/web-token-manipulator.d.ts

@@ -0,0 +1,4 @@
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export interface WebTokenManipulator<T extends JwtTokenBase> {
+    extractTokenFromAuthorizationHeader(header: string): Promise<T>;
+}

package/lib/http/error/bad-gateway.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class BadGateway<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/bad-request-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class BadRequestError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/conflict-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class ConflictError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/forbidden-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class ForbiddenError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/gateway-timeout.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class GatewayTimeout<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/method-not-allowed-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class MethodNotAllowedError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/misconfigured-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class MisconfiguredError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/not-found-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class NotFoundError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/not-implemented.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class NotImplemented<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/request-timeout-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class RequestTimeoutError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/service-unavailable.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class ServiceUnavailable<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/too-many-requests-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class TooManyRequestsError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/error/unauthorized-error.d.ts

@@ -0,0 +1,5 @@
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class UnauthorizedError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}

package/lib/http/event-util.d.ts

@@ -0,0 +1,27 @@
+import { APIGatewayEvent, APIGatewayEventRequestContext, AuthResponseContext } from 'aws-lambda';
+import { EpsilonLoggerConfig } from '../config/epsilon-logger-config.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { BasicAuthToken } from './auth/basic-auth-token.js';
+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;
+    static fixStillEncodedQueryParams(event: APIGatewayEvent): void;
+    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;
+    static hostIsLocal(host: string): boolean;
+    static hostIsLocalOrNotRoutableIP4(host: string): boolean;
+}

package/lib/http/event-util.spec.d.ts

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

package/lib/http/response-util.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ProxyResult } from 'aws-lambda';
+import { RestfulApiHttpError } from '@bitblit/ratchet-common';
+export declare class ResponseUtil {
+    private constructor();
+    static errorResponse<T>(err: RestfulApiHttpError<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/lib/http/response-util.spec.d.ts

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

package/lib/http/route/epsilon-router.d.ts

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

package/lib/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/lib/http/route/route-mapping.d.ts

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

package/lib/http/route/route-validator-config.d.ts

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

package/lib/http/route/router-util.d.ts

@@ -0,0 +1,23 @@
+import { EpsilonRouter } from './epsilon-router.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+import { OpenApiDocument } from '../../config/open-api/open-api-document.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundHttpAdapterHandler } from '../../background/background-http-adapter-handler.js';
+import { HttpConfig } from '../../config/http/http-config.js';
+import { HttpProcessingConfig } from '../../config/http/http-processing-config.js';
+import { WebTokenManipulator } from '../auth/web-token-manipulator.js';
+import { FilterFunction } from '../../config/http/filter-function.js';
+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/lib/http/route/router-util.spec.d.ts

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

package/lib/http/web-handler.d.ts

@@ -0,0 +1,23 @@
+import { EpsilonRouter } from './route/epsilon-router.js';
+import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
+import Route from 'route-parser';
+import { RouteMapping } from './route/route-mapping.js';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event.js';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+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/lib/http/web-handler.spec.d.ts

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