@bitblit/ratchet-epsilon-common 4.0.1-alpha

package/lib/background/manager/aws-sqs-sns-background-manager.d.ts

@@ -0,0 +1,23 @@
+import { GetQueueAttributesCommandOutput, SQSClient } from '@aws-sdk/client-sqs';
+import { BackgroundEntry } from '../background-entry.js';
+import { BackgroundAwsConfig } from '../../config/background/background-aws-config.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
+import { SNSClient } from '@aws-sdk/client-sns';
+export declare class AwsSqsSnsBackgroundManager extends AbstractBackgroundManager {
+    private _awsConfig;
+    private _sqs;
+    private _sns;
+    constructor(_awsConfig: BackgroundAwsConfig, _sqs: SQSClient, _sns: SNSClient);
+    get backgroundManagerName(): string;
+    get awsConfig(): BackgroundAwsConfig;
+    get sqs(): SQSClient;
+    get sns(): SNSClient;
+    addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
+    fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;
+    fireStartProcessingRequest(): Promise<string>;
+    fetchApproximateNumberOfQueueEntries(): Promise<number>;
+    fetchCurrentQueueAttributes(): Promise<GetQueueAttributesCommandOutput>;
+    writeMessageToSnsTopic(message: string): Promise<string>;
+    takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]>;
+}

package/lib/background/manager/background-manager-like.d.ts

@@ -0,0 +1,17 @@
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { Subject } from 'rxjs';
+export interface BackgroundManagerLike {
+    get backgroundManagerName(): string;
+    immediateProcessQueue?(): Subject<InternalBackgroundEntry<any>>;
+    createEntry<T>(type: string, data?: T): BackgroundEntry<T>;
+    wrapEntryForInternal<T>(entry: BackgroundEntry<T>, overrideTraceId?: string, overrideTraceDepth?: number): InternalBackgroundEntry<T>;
+    addEntryToQueueByParts<T>(type: string, data?: T, fireStartMessage?: boolean): Promise<string>;
+    addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
+    addEntriesToQueue(entries: BackgroundEntry<any>[], fireStartMessage?: boolean): Promise<string[]>;
+    fireImmediateProcessRequestByParts<T>(type: string, data?: T): Promise<string>;
+    fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;
+    fireStartProcessingRequest(): Promise<string>;
+    fetchApproximateNumberOfQueueEntries(): Promise<number>;
+    takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]>;
+}

package/lib/background/manager/background-manager.spec.d.ts

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

package/lib/background/manager/single-thread-local-background-manager.d.ts

@@ -0,0 +1,15 @@
+import { Subject } from 'rxjs';
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
+export declare class SingleThreadLocalBackgroundManager extends AbstractBackgroundManager {
+    private _localBus;
+    get backgroundManagerName(): string;
+    constructor();
+    immediateProcessQueue?(): Subject<InternalBackgroundEntry<any>>;
+    addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
+    fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;
+    fireStartProcessingRequest(): Promise<string>;
+    fetchApproximateNumberOfQueueEntries(): Promise<number>;
+    takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]>;
+}

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

@@ -0,0 +1,17 @@
+import { BackgroundTransactionLogger } from '../config/background/background-transaction-logger.js';
+import { BackgroundTransactionLog } from '../config/background/background-transaction-log.js';
+import { S3Client } from '@aws-sdk/client-s3';
+export declare class S3BackgroundTransactionLogger implements BackgroundTransactionLogger {
+    private cfg;
+    private s3TransactionLogCacheRatchet;
+    constructor(cfg: BackgroundS3TransactionLoggingConfig);
+    logTransaction(txLog: BackgroundTransactionLog): Promise<void>;
+    readTransactionLog(txGuid: string): Promise<BackgroundTransactionLog>;
+    static validateConfig(cfg: BackgroundS3TransactionLoggingConfig): string[];
+}
+export interface BackgroundS3TransactionLoggingConfig {
+    s3: S3Client;
+    bucket: string;
+    timeToLiveDays: number;
+    prefix?: string;
+}

package/lib/build/ratchet-epsilon-common-info.d.ts

@@ -0,0 +1,5 @@
+import { BuildInformation } from '@bitblit/ratchet-common';
+export declare class RatchetEpsilonCommonInfo {
+    private constructor();
+    static buildInformation(): BuildInformation;
+}

package/lib/built-in/background/echo-processor.d.ts

@@ -0,0 +1,7 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export declare class EchoProcessor implements BackgroundProcessor<any> {
+    static TYPE_NAME: string;
+    get typeName(): string;
+    handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;
+}

package/lib/built-in/background/log-and-enqueue-echo-processor.d.ts

@@ -0,0 +1,6 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export declare class LogAndEnqueueEchoProcessor implements BackgroundProcessor<any> {
+    get typeName(): string;
+    handleEvent(data: any, cfg: BackgroundManagerLike): Promise<void>;
+}

package/lib/built-in/background/log-message-background-error-processor.d.ts

@@ -0,0 +1,5 @@
+import { BackgroundErrorProcessor } from '../../config/background/background-error-processor.js';
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
+export declare class LogMessageBackgroundErrorProcessor implements BackgroundErrorProcessor {
+    handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void>;
+}

package/lib/built-in/background/no-op-processor.d.ts

@@ -0,0 +1,6 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export declare class NoOpProcessor implements BackgroundProcessor<any> {
+    get typeName(): string;
+    handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;
+}

package/lib/built-in/background/retry-processor.d.ts

@@ -0,0 +1,16 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export declare class RetryProcessor implements BackgroundProcessor<any> {
+    private delegate;
+    private opts;
+    private static readonly RETRY_FIELD_NAME;
+    constructor(delegate: BackgroundProcessor<any>, opts: RetryProcessorOptions);
+    get typeName(): string;
+    handleEvent(data: any, mgr: BackgroundManagerLike): Promise<void>;
+}
+export interface RetryProcessorOptions {
+    retryCount?: number;
+    baseDelayMS?: number;
+    typePrefix?: string;
+    typeSuffix?: string;
+}

package/lib/built-in/background/sample-delay-processor.d.ts

@@ -0,0 +1,6 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export declare class SampleDelayProcessor implements BackgroundProcessor<any> {
+    get typeName(): string;
+    handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;
+}

package/lib/built-in/background/sample-input-validated-processor-data.d.ts

@@ -0,0 +1,4 @@
+export interface SampleInputValidatedProcessorData {
+    nameParam: string;
+    numberParam: number;
+}

package/lib/built-in/background/sample-input-validated-processor.d.ts

@@ -0,0 +1,8 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { SampleInputValidatedProcessorData } from './sample-input-validated-processor-data.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+export declare class SampleInputValidatedProcessor implements BackgroundProcessor<SampleInputValidatedProcessorData> {
+    get typeName(): string;
+    handleEvent(data: SampleInputValidatedProcessorData, mgr?: BackgroundManagerLike): Promise<void>;
+    get dataSchemaName(): string;
+}

package/lib/built-in/built-in-trace-id-generators.d.ts

@@ -0,0 +1,5 @@
+export declare class BuiltInTraceIdGenerators {
+    static fullAwsRequestId(): string;
+    static shortAwsRequestId(): string;
+    static fixedLengthHex(length?: number): string;
+}

package/lib/built-in/daemon/daemon-authorizer-function.d.ts

@@ -0,0 +1,5 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+export interface DaemonAuthorizerFunction {
+    (evt: ExtendedAPIGatewayEvent, proc: DaemonProcessState): Promise<boolean>;
+}

package/lib/built-in/daemon/daemon-config.d.ts

@@ -0,0 +1,8 @@
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function.js';
+import { DaemonGroupSelectionFunction } from './daemon-group-selection-function.js';
+export interface DaemonConfig {
+    authorizer?: DaemonAuthorizerFunction;
+    groupSelector?: DaemonGroupSelectionFunction;
+    fetchDaemonStatusPathParameter?: string;
+    fetchDaemonStatusByPublicTokenPathParameter?: string;
+}

package/lib/built-in/daemon/daemon-group-selection-function.d.ts

@@ -0,0 +1,4 @@
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+export interface DaemonGroupSelectionFunction {
+    (evt: ExtendedAPIGatewayEvent): Promise<string>;
+}

package/lib/built-in/daemon/daemon-handler.d.ts

@@ -0,0 +1,16 @@
+import { DaemonLike } from '@bitblit/ratchet-aws';
+import { DaemonProcessState } from '@bitblit/ratchet-aws';
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function.js';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { DaemonProcessStateList } from './daemon-process-state-list.js';
+import { DaemonConfig } from './daemon-config.js';
+export declare class DaemonHandler {
+    private daemon;
+    private inConfig?;
+    static readonly ALLOW_EVERYTHING_AUTHORIZER: DaemonAuthorizerFunction;
+    private config;
+    constructor(daemon: DaemonLike, inConfig?: DaemonConfig);
+    fetchDaemonStatusByPublicToken(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState>;
+    fetchDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState>;
+    listDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessStateList>;
+}

package/lib/built-in/daemon/daemon-process-state-list.d.ts

@@ -0,0 +1,5 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws';
+export interface DaemonProcessStateList {
+    results: DaemonProcessState[];
+    nextToken: string;
+}

package/lib/built-in/http/apollo-filter.d.ts

@@ -0,0 +1,10 @@
+import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
+import { ApolloServer, CreateHandlerOptions } from 'apollo-server-lambda';
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+export declare class ApolloFilter {
+    private static CACHE_APOLLO_HANDLER;
+    static handlePathWithApollo(fCtx: FilterChainContext, apolloPathRegex: RegExp, apolloServer: ApolloServer, createHandlerOptions: CreateHandlerOptions): Promise<boolean>;
+    static processApolloRequest(event: APIGatewayEvent, context: Context, apolloServer: ApolloServer, createHandlerOptions: CreateHandlerOptions): Promise<ProxyResult>;
+    static addApolloFilterToList(filters: FilterFunction[], apolloPathRegex: RegExp, apolloServer: ApolloServer, createHandlerOptions: CreateHandlerOptions): void;
+}

package/lib/built-in/http/built-in-auth-filters.d.ts

@@ -0,0 +1,9 @@
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+import { WebTokenManipulator } from '../../http/auth/web-token-manipulator.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export declare class BuiltInAuthFilters {
+    static requireAllRolesInCommonJwt(fCtx: FilterChainContext, requiredRoleAllOf: string[]): Promise<boolean>;
+    static requireAnyRoleInCommonJwt(fCtx: FilterChainContext, requiredRoleOneOf: string[]): Promise<boolean>;
+    static parseAuthorizationHeader(fCtx: FilterChainContext, webTokenManipulators: WebTokenManipulator<JwtTokenBase> | WebTokenManipulator<JwtTokenBase>[]): Promise<boolean>;
+    static applyOpenApiAuthorization(fCtx: FilterChainContext): Promise<boolean>;
+}

package/lib/built-in/http/built-in-authorizers.d.ts

@@ -0,0 +1,8 @@
+import { APIGatewayEvent } from 'aws-lambda';
+import { RouteMapping } from '../../http/route/route-mapping.js';
+import { EpsilonAuthorizationContext } from '../../config/http/epsilon-authorization-context.js';
+export declare class BuiltInAuthorizers {
+    static simpleNoAuthenticationLogAccess(authorizationContext: EpsilonAuthorizationContext<any>, evt: APIGatewayEvent): Promise<boolean>;
+    static simpleLoggedInAuth(authorizationContext: EpsilonAuthorizationContext<any>, evt: APIGatewayEvent): Promise<boolean>;
+    static simpleRoleRouteAuth(authorizationContext: EpsilonAuthorizationContext<any>, event: APIGatewayEvent, route: RouteMapping, requiredRoleOneOf?: string[], requiredRoleAllOf?: string[]): Promise<boolean>;
+}

package/lib/built-in/http/built-in-filters.d.ts

@@ -0,0 +1,25 @@
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+export declare class BuiltInFilters {
+    static readonly MAXIMUM_LAMBDA_BODY_SIZE_BYTES: number;
+    static combineFilters(fCtx: FilterChainContext, filters: FilterFunction[]): Promise<boolean>;
+    static applyGzipIfPossible(fCtx: FilterChainContext): Promise<boolean>;
+    static addConstantHeaders(fCtx: FilterChainContext, headers: Record<string, string>): Promise<boolean>;
+    static addAWSRequestIdHeader(fCtx: FilterChainContext, headerName?: string): Promise<boolean>;
+    static addAllowEverythingCORSHeaders(fCtx: FilterChainContext): Promise<boolean>;
+    static addAllowReflectionCORSHeaders(fCtx: FilterChainContext): Promise<boolean>;
+    static uriDecodeQueryParams(fCtx: FilterChainContext): Promise<boolean>;
+    static fixStillEncodedQueryParams(fCtx: FilterChainContext): Promise<boolean>;
+    static disallowStringNullAsPathParameter(fCtx: FilterChainContext): Promise<boolean>;
+    static disallowStringNullAsQueryStringParameter(fCtx: FilterChainContext): Promise<boolean>;
+    static ensureEventMaps(fCtx: FilterChainContext): Promise<boolean>;
+    static parseJsonBodyToObject(fCtx: FilterChainContext): Promise<boolean>;
+    static checkMaximumLambdaBodySize(fCtx: FilterChainContext): Promise<boolean>;
+    static validateInboundBody(fCtx: FilterChainContext): Promise<boolean>;
+    static validateInboundQueryParams(fCtx: FilterChainContext): Promise<boolean>;
+    static validateInboundPathParams(fCtx: FilterChainContext): Promise<boolean>;
+    static validateOutboundResponse(fCtx: FilterChainContext): Promise<boolean>;
+    static autoRespondToOptionsRequestWithCors(fCtx: FilterChainContext): Promise<boolean>;
+    static autoRespond(fCtx: FilterChainContext, inBody: any): Promise<boolean>;
+    static secureOutboundServerErrorForProduction(fCtx: FilterChainContext, errorMessage: string, errCode: number): Promise<boolean>;
+}

package/lib/built-in/http/built-in-handlers.d.ts

@@ -0,0 +1,9 @@
+import { APIGatewayEvent, Context } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { EpsilonRouter } from '../../http/route/epsilon-router.js';
+export declare class BuiltInHandlers {
+    static expectedHandledByFilter(evt: ExtendedAPIGatewayEvent, flag?: string): Promise<any>;
+    static handleNotImplemented(evt: ExtendedAPIGatewayEvent, flag?: string): Promise<any>;
+    static sample(evt: ExtendedAPIGatewayEvent, flag?: string, context?: Context): Promise<any>;
+    static defaultErrorProcessor(event: APIGatewayEvent, err: Error, cfg: EpsilonRouter): Promise<void>;
+}

package/lib/built-in/http/log-level-manipulation-filter.d.ts

@@ -0,0 +1,6 @@
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+export declare class LogLevelManipulationFilter {
+    private static LOG_LEVEL_BEFORE_CHANGE;
+    static setLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;
+    static clearLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;
+}

package/lib/built-in/http/run-handler-as-filter.d.ts

@@ -0,0 +1,12 @@
+import { Context } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { RouteAndParse } from '../../http/web-handler.js';
+import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling.js';
+import { FilterFunction } from '../../config/http/filter-function.js';
+import { FilterChainContext } from '../../config/http/filter-chain-context.js';
+export declare class RunHandlerAsFilter {
+    static runHandler(fCtx: FilterChainContext, rm: RouteAndParse): Promise<boolean>;
+    static applyNullReturnedObjectHandling(result: any, handling: NullReturnedObjectHandling): any;
+    static findHandler(rm: RouteAndParse, event: ExtendedAPIGatewayEvent, context: Context, add404OnMissing?: boolean): Promise<any>;
+    static addRunHandlerAsFilterToList(filters: FilterFunction[], rm: RouteAndParse): void;
+}

package/lib/built-in/http/run-handler-as-filter.spec.d.ts

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

package/lib/cli/ratchet-cli-handler.d.ts

@@ -0,0 +1,6 @@
+import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only';
+import { BuildInformation } from '@bitblit/ratchet-common';
+export declare class RatchetCliHandler extends AbstractRatchetCliHandler {
+    fetchHandlerMap(): Record<string, any>;
+    fetchVersionInfo(): BuildInformation;
+}

package/lib/cli/run-background-process-from-command-line.d.ts

@@ -0,0 +1,3 @@
+export declare class RunBackgroundProcessFromCommandLine {
+    static runFromCliArgs(args: string[]): Promise<void>;
+}

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

@@ -0,0 +1,7 @@
+export interface BackgroundAwsConfig {
+    queueUrl: string;
+    notificationArn: string;
+    sendNotificationOnBackgroundError?: boolean;
+    sendNotificationOnBackgroundValidationFailure?: boolean;
+    backgroundProcessFailureSnsArn?: string;
+}

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

@@ -0,0 +1,14 @@
+import { BackgroundProcessor } from './background-processor.js';
+import { BackgroundErrorProcessor } from './background-error-processor.js';
+import { BackgroundExecutionListener } from '../../background/background-execution-listener.js';
+import { BackgroundTransactionLogger } from './background-transaction-logger.js';
+export interface BackgroundConfig {
+    transactionLogger?: BackgroundTransactionLogger;
+    errorProcessor?: BackgroundErrorProcessor;
+    httpStatusEndpoint?: string;
+    httpMetaEndpoint?: string;
+    httpSubmissionPath: string;
+    implyTypeFromPathSuffix: boolean;
+    processors: BackgroundProcessor<any>[];
+    executionListeners?: BackgroundExecutionListener<any>[];
+}

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[];
+}