@bitblit/ratchet-epsilon-common 4.0.353-alpha → 4.0.355-alpha

package/lib/types.d.ts

@@ -0,0 +1,1200 @@
+import { APIGatewayEvent, Context, ProxyResult, DynamoDBStreamEvent, S3Event, SNSEvent, SQSEvent, APIGatewayEventRequestContext, AuthResponseContext, APIGatewayProxyEventV2, CustomAuthorizerEvent, Callback, ScheduledEvent, APIGatewayEventRequestContextV2, APIGatewayEventRequestContextWithAuthorizer } from 'aws-lambda';
+import { LogMessageFormatType, LoggerLevelName, LoggerOptions, LogMessageProcessor, LogMessage, BuildInformation, JwtTokenBase, JwtRatchetLike, RestfulApiHttpError, JwtRatchet } from '@bitblit/ratchet-common';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import Route from 'route-parser';
+import { Subject } from 'rxjs';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { IncomingMessage, ServerResponse } from 'http';
+import { DynamoRatchetLike, S3CacheRatchetLike, DaemonProcessState, DaemonLike } from '@bitblit/ratchet-aws';
+import { S3Client } from '@aws-sdk/client-s3';
+import { SQSClient, GetQueueAttributesCommandOutput } from '@aws-sdk/client-sqs';
+import { BaseContext, ContextFunction, ApolloServer } from '@apollo/server';
+import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only';
+
+declare class EpsilonBuildProperties {
+    private constructor();
+    static get buildVersion(): string;
+    static get buildHash(): string;
+    static get buildBranch(): string;
+    static get buildTag(): string;
+    static get buildBranchOrTag(): string;
+    static get buildTime(): string;
+}
+
+interface BackgroundEntry<T> {
+    type: string;
+    data: T;
+}
+
+interface EpsilonAuthorizationContext<T> {
+    raw: string;
+    auth: T;
+    error: string;
+}
+
+interface ExtendedAPIGatewayEvent extends APIGatewayEvent {
+    parsedBody: any;
+    authorization: EpsilonAuthorizationContext<any>;
+    convertedFromV2Event: boolean;
+}
+
+interface HandlerFunction<T> {
+    (event: ExtendedAPIGatewayEvent, context?: Context): Promise<T>;
+}
+
+interface RouteValidatorConfig {
+    modelName: string;
+    emptyAllowed: boolean;
+    extraPropertiesAllowed: boolean;
+}
+
+declare const NullReturnedObjectHandling: {
+    Error: string;
+    ConvertToEmptyString: string;
+    Return404NotFoundResponse: string;
+};
+type NullReturnedObjectHandling = (typeof NullReturnedObjectHandling)[keyof typeof NullReturnedObjectHandling];
+
+interface EpsilonRouter {
+    routes: RouteMapping[];
+    openApiModelValidator: ModelValidator;
+    config: HttpConfig;
+}
+
+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>;
+}
+
+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;
+}
+interface RouteAndParse {
+    mapping: RouteMapping;
+    route: Route;
+    parsed: any;
+}
+
+interface FilterChainContext {
+    event: ExtendedAPIGatewayEvent;
+    context: Context;
+    rawResult: any;
+    result: ProxyResult;
+    routeAndParse: RouteAndParse;
+    modelValidator: ModelValidator;
+    authenticators: Map<string, AuthorizerFunction>;
+}
+
+interface FilterFunction {
+    (fCtx: FilterChainContext): Promise<boolean>;
+}
+
+interface HttpProcessingConfig {
+    configName?: string;
+    timeoutMS: number;
+    overrideAuthorizerName?: string;
+    preFilters?: FilterFunction[];
+    postFilters?: FilterFunction[];
+    errorFilters?: FilterFunction[];
+    nullReturnedObjectHandling?: NullReturnedObjectHandling;
+}
+
+interface RouteMapping {
+    method: string;
+    path: string;
+    function: HandlerFunction<any>;
+    metaProcessingConfig: HttpProcessingConfig;
+    validation: RouteValidatorConfig;
+    outboundValidation: RouteValidatorConfig;
+    authorizerName: string;
+}
+
+interface AuthorizerFunction {
+    (authData: EpsilonAuthorizationContext<any>, event?: ExtendedAPIGatewayEvent, route?: RouteMapping): Promise<boolean>;
+}
+
+interface MappedHttpProcessingConfig {
+    methods?: string[];
+    pathRegex: string;
+    invertPathMatching?: boolean;
+    config: HttpProcessingConfig;
+}
+
+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[];
+}
+
+interface InternalBackgroundEntry<T> extends BackgroundEntry<T> {
+    guid: string;
+    createdEpochMS: number;
+    traceId: string;
+    traceDepth: number;
+    meta?: Record<string, string>;
+}
+
+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): Promise<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>[]>;
+    modifyPayloadPreProcess?<T>(entry: InternalBackgroundEntry<T>): Promise<InternalBackgroundEntry<T>>;
+}
+
+interface BackgroundProcessor<T> {
+    typeName: string;
+    dataSchemaName?: string;
+    handleEvent(data: T, mgr: BackgroundManagerLike): Promise<any>;
+}
+
+interface BackgroundErrorProcessor {
+    handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void>;
+}
+
+declare const BackgroundExecutionEventType: {
+    ProcessStarting: string;
+    DataValidationError: string;
+    ExecutionSuccessfullyComplete: string;
+    ExecutionFailedError: string;
+    NoMatchProcessorName: string;
+};
+type BackgroundExecutionEventType = (typeof BackgroundExecutionEventType)[keyof typeof BackgroundExecutionEventType];
+
+interface BackgroundExecutionEvent<T> {
+    type: BackgroundExecutionEventType;
+    guid: string;
+    processorType: string;
+    data: T;
+    errors?: string[];
+}
+
+interface BackgroundExecutionListener<T> {
+    label?: string;
+    onEvent(event: BackgroundExecutionEvent<T>): Promise<void>;
+}
+
+interface BackgroundTransactionLog {
+    request: InternalBackgroundEntry<any>;
+    running: boolean;
+    runtimeMS?: number;
+    result?: any;
+    error?: any;
+}
+
+interface BackgroundTransactionLogger {
+    logTransaction(txLog: BackgroundTransactionLog): Promise<void>;
+    readTransactionLog(txGuid: string): Promise<BackgroundTransactionLog>;
+}
+
+interface BackgroundConfig {
+    transactionLogger?: BackgroundTransactionLogger;
+    errorProcessor?: BackgroundErrorProcessor;
+    httpStatusEndpoint?: string;
+    httpMetaEndpoint?: string;
+    httpSubmissionPath: string;
+    implyTypeFromPathSuffix: boolean;
+    processors: BackgroundProcessor<any>[];
+    executionListeners?: BackgroundExecutionListener<any>[];
+}
+
+interface AbstractCronEntry {
+    name?: string;
+    eventFilter?: RegExp;
+    minuteFilter?: number[];
+    hourFilter?: number[];
+    dayOfWeekFilter?: number[];
+    dayOfMonthFilter?: number[];
+    monthOfYearFilter?: number[];
+    contextMatchFilter?: RegExp;
+    contextNoMatchFilter?: RegExp;
+    overrideTimezone?: string;
+}
+
+interface CronBackgroundEntry extends AbstractCronEntry {
+    backgroundTaskType: string;
+    fireImmediate: boolean;
+    data?: any;
+}
+
+interface CronConfig {
+    timezone: string;
+    context: string;
+    entries: CronBackgroundEntry[];
+}
+
+interface GenericAwsEventHandlerFunction<T> {
+    (event: T): Promise<void>;
+}
+
+interface DynamoDbConfig {
+    handlers: Map<string, GenericAwsEventHandlerFunction<DynamoDBStreamEvent>>;
+}
+
+interface S3Config {
+    createHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;
+    removeHandlers: Map<string, GenericAwsEventHandlerFunction<S3Event>>;
+}
+
+interface SnsConfig {
+    handlers: Map<string, GenericAwsEventHandlerFunction<SNSEvent>>;
+}
+
+interface LoggingTraceIdGenerator {
+    (event?: any, context?: Context): string;
+}
+
+interface EpsilonLoggerConfig {
+    envParamLogLevelName?: string;
+    queryParamLogLevelName?: string;
+    queryParamTracePrefixName?: string;
+    traceIdGenerator?: LoggingTraceIdGenerator;
+    logMessageFormatType?: LogMessageFormatType;
+    traceHeaderName?: string;
+    traceDepthHeaderName?: string;
+    epsilonStartEndMessageLogLevel?: LoggerLevelName;
+}
+
+interface InterApiAwsConfig {
+    localMode: boolean;
+    source: string;
+    snsArn: string;
+}
+
+interface InterApiProcessMapping {
+    sourceRegex: string;
+    typeRegex: string;
+    disabled: boolean;
+    backgroundProcessTypes: string[];
+}
+
+interface InterApiConfig {
+    aws: InterApiAwsConfig;
+    processMappings: InterApiProcessMapping[];
+}
+
+interface SqsConfig {
+    handlers: Map<string, GenericAwsEventHandlerFunction<SQSEvent>>;
+}
+
+interface EpsilonConfig {
+    label?: string;
+    disableLastResortTimeout?: boolean;
+    throwErrorIfNoSuitableEventHandlers?: boolean;
+    openApiYamlString: string;
+    httpConfig?: HttpConfig;
+    backgroundConfig?: BackgroundConfig;
+    interApiConfig?: InterApiConfig;
+    cron?: CronConfig;
+    dynamoDb?: DynamoDbConfig;
+    s3?: S3Config;
+    sns?: SnsConfig;
+    sqs?: SqsConfig;
+    loggerConfig?: EpsilonLoggerConfig;
+}
+
+declare class BackgroundHandler implements EpsilonLambdaEventHandler<SNSEvent> {
+    private cfg;
+    private mgr;
+    private modelValidator?;
+    private processors;
+    private validator;
+    constructor(cfg: BackgroundConfig, mgr: BackgroundManagerLike, modelValidator?: ModelValidator);
+    extractLabel(evt: SNSEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    isBackgroundSNSEvent(event: any): boolean;
+    isBackgroundStartSnsEvent(event: any): boolean;
+    isBackgroundImmediateFireEvent(event: any): boolean;
+    parseImmediateFireBackgroundEntry(event: any): InternalBackgroundEntry<any>;
+    processEvent(event: any, context: Context): Promise<ProxyResult>;
+    private takeAndProcessSingleBackgroundQueueEntry;
+    private safeWriteToLogger;
+    private conditionallyStartTransactionLog;
+    private conditionallyCompleteTransactionLog;
+    private conditionallyRunErrorProcessor;
+    private fireListenerEvent;
+    processSingleBackgroundEntry(inE: InternalBackgroundEntry<any>): Promise<boolean>;
+    getConfig(): BackgroundConfig;
+}
+
+interface OpenApiDocumentComponents {
+    securitySchemes: any[];
+    schemas: any[];
+}
+
+interface OpenApiDocumentPath {
+}
+
+interface OpenApiDocument {
+    components: OpenApiDocumentComponents;
+    paths: OpenApiDocumentPath[];
+}
+
+interface EpsilonInstance {
+    config: EpsilonConfig;
+    parsedOpenApiDoc: OpenApiDocument;
+    modelValidator: ModelValidator;
+    webHandler: WebHandler;
+    backgroundHandler: BackgroundHandler;
+    backgroundManager: BackgroundManagerLike;
+}
+
+declare class EpsilonGlobalHandler {
+    private _epsilon;
+    private static LOGGER_CONFIGURED;
+    private static GLOBAL_INSTANCE_PROVIDER;
+    static set globalInstanceProvider(input: () => Promise<EpsilonGlobalHandler>);
+    static get globalInstanceProvider(): () => Promise<EpsilonGlobalHandler>;
+    private handlers;
+    constructor(_epsilon: EpsilonInstance);
+    static configureDefaultLogger(overrides?: LoggerOptions): void;
+    get epsilon(): EpsilonInstance;
+    processSingleBackgroundByParts<T>(type: string, data?: T, overrideTraceId?: string, overrideTraceDepth?: number): Promise<boolean>;
+    processSingleBackgroundEntry(e: BackgroundEntry<any>, overrideTraceId?: string, overrideTraceDepth?: number): Promise<boolean>;
+    lambdaHandler(event: any, context: Context): Promise<any>;
+    innerLambdaHandler(event: any, context: Context): Promise<any>;
+    static defaultProcessUncaughtError(event: any, context: Context, err: any): Promise<ProxyResult>;
+}
+
+declare class EpsilonConstants {
+    static readonly EPSILON_FINDER_DYNAMIC_IMPORT_PATH_ENV_NAME = "EPSILON_FINDER_DYNAMIC_IMPORT_PATH";
+    static readonly EPSILON_FINDER_FUNCTION_NAME_ENV_NAME = "EPSILON_FINDER_FUNCTION_NAME";
+    static readonly DEFAULT_EPSILON_FINDER_DYNAMIC_IMPORT_PATH = "epsilon-global-handler-provider.js";
+    static readonly DEFAULT_EPSILON_FINDER_FUNCTION_NAME = "findEpsilonGlobalHandler";
+    static readonly AUTH_HEADER_PREFIX: string;
+    static readonly AUTH_HEADER_NAME: string;
+    static readonly BACKGROUND_SQS_TYPE_FIELD = "BACKGROUND_TYPE";
+    static readonly BACKGROUND_SNS_START_MARKER = "BACKGROUND_START_MARKER";
+    static readonly BACKGROUND_SNS_IMMEDIATE_RUN_FLAG = "BACKGROUND_IMMEDIATE_RUN_FLAG";
+    static readonly INTER_API_SNS_EVENT = "EPSILON_INTER_API_EVENT";
+    private static load;
+    static findDynamicImportEpsilonGlobalHandlerProvider(): Promise<EpsilonGlobalHandler>;
+    private constructor();
+}
+
+declare class EpsilonLoggingExtensionProcessor implements LogMessageProcessor {
+    process(msg: LogMessage): LogMessage;
+    label(): string;
+}
+
+interface InterApiEntry<T> {
+    source: string;
+    type: string;
+    data: T;
+    traceId?: string;
+    traceDepth?: number;
+}
+
+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>;
+}
+
+declare class LocalContainerServer {
+    private port;
+    private containerUrl;
+    private server;
+    private aborted;
+    constructor(port?: number, containerUrl?: string);
+    runServer(): Promise<boolean>;
+    requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any>;
+    static runFromCliArgs(args: string[]): Promise<void>;
+}
+
+declare class LocalServerCert {
+    static readonly CLIENT_CSR: string;
+    static readonly CLIENT_CERT_PEM: string;
+    static readonly CLIENT_KEY_PEM: string;
+}
+
+declare class LocalServer {
+    private globalHandler;
+    private port;
+    private https;
+    private server;
+    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, logLevel: LoggerLevelName): Promise<boolean>;
+    static parseQueryParamsFromUrlString(urlString: string): {
+        [key: string]: string;
+    };
+    static runSampleBatchOnlyServerFromCliArgs(args: string[]): Promise<void>;
+    static runSampleLocalServerFromCliArgs(args: string[]): Promise<void>;
+}
+
+declare class BackgroundDynamoLogTableHandler<T> implements BackgroundExecutionListener<T> {
+    private dynamo;
+    private tableName;
+    private env;
+    private backgroundQueueName;
+    constructor(dynamo: DynamoRatchetLike, tableName: string, env: string, backgroundQueueName: string);
+    onEvent(event: BackgroundExecutionEvent<T>): Promise<void>;
+}
+
+declare const BackgroundProcessHandling: {
+    Queued: string;
+    Immediate: string;
+};
+type BackgroundProcessHandling = (typeof BackgroundProcessHandling)[keyof typeof BackgroundProcessHandling];
+
+interface BackgroundQueueResponseInternal {
+    processHandling: BackgroundProcessHandling;
+    startProcessorRequested: boolean;
+    success: boolean;
+    resultId: string;
+    error: string;
+}
+
+interface BackgroundMetaResponseInternal {
+    backgroundManagerName: string;
+    currentQueueLength: number;
+    validTypes: string[];
+}
+
+declare class BackgroundHttpAdapterHandler {
+    private backgroundConfig;
+    private modelValidator;
+    private backgroundManager;
+    private maxWaitInMsForBackgroundJobToStart;
+    constructor(backgroundConfig: BackgroundConfig, modelValidator: ModelValidator, backgroundManager: BackgroundManagerLike, maxWaitInMsForBackgroundJobToStart?: number);
+    get httpMetaEndpoint(): string;
+    get httpSubmissionPath(): string;
+    get httpStatusPath(): string;
+    get implyTypeFromPathSuffix(): boolean;
+    handleBackgroundStatusRequest(evt: ExtendedAPIGatewayEvent, context: Context): Promise<BackgroundTransactionLog>;
+    handleBackgroundMetaRequest(evt: ExtendedAPIGatewayEvent, context: Context): Promise<BackgroundMetaResponseInternal>;
+    handleBackgroundSubmission(evt: ExtendedAPIGatewayEvent, context: Context): Promise<BackgroundQueueResponseInternal>;
+}
+
+interface BackgroundProcessLogTableEntry {
+    env: string;
+    backgroundQueueName: string;
+    requestId: string;
+    guid: string;
+    processTypeName: string;
+    state: string;
+    timestampEpochMs: number;
+    errors?: string[];
+    params?: any;
+}
+
+interface BackgroundAwsConfig {
+    queueUrl: string;
+    notificationArn: string;
+    sendNotificationOnBackgroundError?: boolean;
+    sendNotificationOnBackgroundValidationFailure?: boolean;
+    backgroundProcessFailureSnsArn?: string;
+}
+
+declare class BackgroundValidator {
+    private cfg;
+    private modelValidator;
+    constructor(cfg: BackgroundConfig, modelValidator: ModelValidator);
+    findProcessor(typeName: string): BackgroundProcessor<any>;
+    validType(type: string): boolean;
+    validateEntry<T>(entry: BackgroundEntry<T>): string[];
+    validateEntryAndThrowException<T>(entry: BackgroundEntry<T>): void;
+    static validateAndMapProcessors(processorInput: BackgroundProcessor<any>[], modelValidator: ModelValidator): Map<string, BackgroundProcessor<any>>;
+    static validateAwsConfig(cfg: BackgroundAwsConfig): string[];
+    static validateConfig(cfg: BackgroundConfig): string[];
+}
+
+declare class EpsilonBackgroundProcessError<T = void> extends Error {
+    private static readonly EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY;
+    private _errors;
+    private _detailErrorCode;
+    private _details;
+    private _requestId;
+    private _wrappedError;
+    constructor(...errors: string[]);
+    static combineErrorStringsWithDefault(errors: string[], defMessage?: string): string;
+    setFormattedErrorMessage(format: string, ...input: any[]): void;
+    withFormattedErrorMessage(format: string, ...input: any[]): EpsilonBackgroundProcessError<T>;
+    withErrors(errors: string[]): EpsilonBackgroundProcessError<T>;
+    withDetailErrorCode(detailErrorCode: number): EpsilonBackgroundProcessError<T>;
+    withDetails(details: T): EpsilonBackgroundProcessError<T>;
+    withRequestId(requestId: string): EpsilonBackgroundProcessError<T>;
+    withWrappedError(err: Error): EpsilonBackgroundProcessError<T>;
+    isWrappedError(): boolean;
+    static wrapError<T = void>(err: Error): EpsilonBackgroundProcessError<T>;
+    static objectIsEpsilonBackgroundProcessError(obj: any): boolean;
+    set errors(value: string[]);
+    get errors(): string[];
+    set detailErrorCode(value: number);
+    get detailErrorCode(): number;
+    set details(value: T);
+    get details(): T;
+    set requestId(value: string);
+    get requestId(): string;
+    set wrappedError(value: Error);
+    get wrappedError(): Error;
+}
+
+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[];
+}
+interface BackgroundS3TransactionLoggingConfig {
+    s3: S3Client;
+    bucket: string;
+    timeToLiveDays: number;
+    prefix?: string;
+}
+
+declare abstract class AbstractBackgroundManager implements BackgroundManagerLike {
+    abstract addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
+    abstract fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;
+    abstract fireStartProcessingRequest(): Promise<string>;
+    abstract fetchApproximateNumberOfQueueEntries(): Promise<number>;
+    abstract get backgroundManagerName(): string;
+    abstract takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]>;
+    createEntry<T>(type: string, data?: T): BackgroundEntry<T>;
+    wrapEntryForInternal<T>(entry: BackgroundEntry<T>, overrideTraceId?: string, overrideTraceDepth?: number): Promise<InternalBackgroundEntry<T>>;
+    addEntryToQueueByParts<T>(type: string, data?: T, fireStartMessage?: boolean): Promise<string>;
+    addEntriesToQueue(entries: BackgroundEntry<any>[], fireStartMessage?: boolean): Promise<string[]>;
+    fireImmediateProcessRequestByParts<T>(type: string, data?: T): Promise<string>;
+    static generateBackgroundGuid(targetEpochMS?: number): string;
+    static backgroundGuidToPath(prefix: string, guid: string): string;
+    static pathToBackgroundGuid(prefix: string, path: string): string;
+}
+
+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>[]>;
+}
+
+declare class AwsLargePayloadS3SqsSnsBackgroundManager extends AwsSqsSnsBackgroundManager {
+    private _s3;
+    private pathPrefix;
+    private static readonly LARGE_MESSAGE_SIZE_THRESHOLD;
+    private static readonly LARGE_MESSAGE_S3_PATH_META_KEY;
+    constructor(_awsConfig: BackgroundAwsConfig, _sqs: SQSClient, _sns: SNSClient, _s3: S3CacheRatchetLike, pathPrefix?: string);
+    get backgroundManagerName(): string;
+    get s3(): S3CacheRatchetLike;
+    wrapEntryForInternal<T>(entry: BackgroundEntry<T>, overrideTraceId?: string, overrideTraceDepth?: number): Promise<InternalBackgroundEntry<T>>;
+    private writeMessageToS3;
+    modify<T>(entry: InternalBackgroundEntry<T>): Promise<InternalBackgroundEntry<T>>;
+}
+
+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>[]>;
+}
+
+declare class RatchetEpsilonCommonInfo {
+    private constructor();
+    static buildInformation(): BuildInformation;
+}
+
+declare class BuiltInTraceIdGenerators {
+    static fullAwsRequestId(): string;
+    static shortAwsRequestId(): string;
+    static fixedLengthHex(length?: number): string;
+}
+
+declare class EchoProcessor implements BackgroundProcessor<any> {
+    static TYPE_NAME: string;
+    get typeName(): string;
+    handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;
+}
+
+declare class LogAndEnqueueEchoProcessor implements BackgroundProcessor<any> {
+    get typeName(): string;
+    handleEvent(data: any, cfg: BackgroundManagerLike): Promise<void>;
+}
+
+declare class LogMessageBackgroundErrorProcessor implements BackgroundErrorProcessor {
+    handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void>;
+}
+
+declare class NoOpProcessor implements BackgroundProcessor<any> {
+    get typeName(): string;
+    handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;
+}
+
+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>;
+}
+interface RetryProcessorOptions {
+    retryCount?: number;
+    baseDelayMS?: number;
+    typePrefix?: string;
+    typeSuffix?: string;
+}
+
+declare class SampleDelayProcessor implements BackgroundProcessor<any> {
+    get typeName(): string;
+    handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;
+}
+
+interface SampleInputValidatedProcessorData {
+    nameParam: string;
+    numberParam: number;
+}
+
+declare class SampleInputValidatedProcessor implements BackgroundProcessor<SampleInputValidatedProcessorData> {
+    get typeName(): string;
+    handleEvent(data: SampleInputValidatedProcessorData, mgr?: BackgroundManagerLike): Promise<void>;
+    get dataSchemaName(): string;
+}
+
+interface DaemonAuthorizerFunction {
+    (evt: ExtendedAPIGatewayEvent, proc: DaemonProcessState): Promise<boolean>;
+}
+
+interface DaemonGroupSelectionFunction {
+    (evt: ExtendedAPIGatewayEvent): Promise<string>;
+}
+
+interface DaemonConfig {
+    authorizer?: DaemonAuthorizerFunction;
+    groupSelector?: DaemonGroupSelectionFunction;
+    fetchDaemonStatusPathParameter?: string;
+    fetchDaemonStatusByPublicTokenPathParameter?: string;
+}
+
+interface DaemonProcessStateList {
+    results: DaemonProcessState[];
+    nextToken: string;
+}
+
+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>;
+}
+
+interface EpsilonLambdaApolloContextFunctionArgument {
+    lambdaEvent: APIGatewayEvent;
+    lambdaContext: Context;
+}
+
+declare const EpsilonApolloCorsMethod: {
+    None: string;
+    All: string;
+    Reflective: string;
+};
+type EpsilonApolloCorsMethod = (typeof EpsilonApolloCorsMethod)[keyof typeof EpsilonApolloCorsMethod];
+
+interface EpsilonLambdaApolloOptions<TContext extends BaseContext> {
+    context?: ContextFunction<[EpsilonLambdaApolloContextFunctionArgument], TContext>;
+    timeoutMS?: number;
+    corsMethod?: EpsilonApolloCorsMethod;
+    debugOutputCallback?: (resp: ProxyResult) => Promise<void>;
+}
+
+declare class ApolloFilter {
+    static handlePathWithApollo<T>(fCtx: FilterChainContext, apolloPathRegex: RegExp, apolloServer: ApolloServer<T>, options?: EpsilonLambdaApolloOptions<T>): Promise<boolean>;
+    static processApolloRequest<T>(event: APIGatewayEvent, context: Context, apolloServer: ApolloServer<T>, options?: EpsilonLambdaApolloOptions<T>): Promise<ProxyResult>;
+    static addApolloFilterToList(filters: FilterFunction[], apolloPathRegex: RegExp, apolloServer: ApolloServer, options?: EpsilonLambdaApolloOptions<BaseContext>): void;
+}
+
+interface WebTokenManipulator<T extends JwtTokenBase> {
+    extractTokenFromAuthorizationHeader(header: string): Promise<T>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+    private static decodeUriComponentAndReplacePlus;
+    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>;
+}
+
+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>;
+}
+
+declare class LogLevelManipulationFilter {
+    private static LOG_LEVEL_BEFORE_CHANGE;
+    static setLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;
+    static clearLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;
+}
+
+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;
+}
+
+interface DefaultEpsilonApolloContext<T extends JwtTokenBase> {
+    user?: T;
+    bearerTokenString?: string;
+    headers: Record<string, string>;
+    functionName: string;
+    lambdaEvent: APIGatewayEvent;
+    lambdaContext: Context;
+}
+
+declare class ApolloUtil {
+    private constructor();
+    static emptyContext<T extends BaseContext>(): Promise<T>;
+    static defaultEpsilonApolloContext(args: EpsilonLambdaApolloContextFunctionArgument, jwt?: JwtRatchetLike): Promise<DefaultEpsilonApolloContext<any>>;
+    static nonRouteableOnlyEpsilonApolloContext(args: EpsilonLambdaApolloContextFunctionArgument, jwt?: JwtRatchetLike): Promise<DefaultEpsilonApolloContext<any>>;
+}
+
+declare class RatchetCliHandler extends AbstractRatchetCliHandler {
+    fetchHandlerMap(): Record<string, any>;
+    fetchVersionInfo(): BuildInformation;
+}
+
+declare class RunBackgroundProcessFromCommandLine {
+    static runFromCliArgs(args: string[]): Promise<void>;
+}
+
+declare class NoHandlersFoundError extends Error {
+    constructor(msg?: string);
+}
+
+interface BasicAuthToken {
+    username: string;
+    password: string;
+}
+
+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(evt: 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;
+}
+
+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>;
+}
+
+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>;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class BadGateway<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class BadRequestError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class ConflictError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class ForbiddenError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class GatewayTimeout<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class MethodNotAllowedError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class MisconfiguredError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class NotFoundError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class NotImplemented<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class RequestTimeoutError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class ServiceUnavailable<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class TooManyRequestsError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+declare class UnauthorizedError<T = void> extends RestfulApiHttpError<T> {
+    static readonly HTTP_CODE: number;
+    constructor(...errors: string[]);
+}
+
+interface ExtendedAuthResponseContext extends AuthResponseContext {
+    userData: any;
+    userDataJSON: string;
+    srcData: string;
+}
+
+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;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class GenericSqsEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<SQSEvent> {
+    private _epsilon;
+    constructor(_epsilon: EpsilonInstance);
+    extractLabel(evt: SQSEvent, context: Context): string;
+    handlesEvent(evt: any): boolean;
+    processEvent(evt: SQSEvent, context: Context): Promise<ProxyResult>;
+    processUncaughtError(event: SQSEvent, context: Context, err: any): Promise<ProxyResult>;
+}
+
+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>;
+}
+
+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>;
+}
+
+interface OpenApiDocModifications {
+    newServerPath: string;
+    removeEndpoints: RegExp[];
+    removeTags: string[];
+    removeSchemas: string[];
+    sortEndpoints: boolean;
+    sortSchemas: boolean;
+}
+
+declare class OpenApiDocModifier {
+    private options;
+    constructor(options: OpenApiDocModifications);
+    modifyOpenApiDoc(yamlString: string): string;
+    private matchNone;
+}
+
+declare class YamlCombiner {
+    static combine(files: string[], inRootPath?: string[]): string;
+}
+
+declare class SampleServerComponents {
+    private constructor();
+    static createSampleApollo(): Promise<ApolloServer>;
+    static createSampleEpsilonConfig(label: string): Promise<EpsilonConfig>;
+    static createSampleEpsilonGlobalHandler(label: string): Promise<EpsilonGlobalHandler>;
+    static createSampleBatchOnlyEpsilonGlobalHandler(label: string): Promise<EpsilonGlobalHandler>;
+}
+
+declare class SampleServerStaticFiles {
+    private constructor();
+    static readonly SAMPLE_OPEN_API_DOC: string;
+    static readonly SAMPLE_SERVER_GRAPHQL: string;
+}
+
+declare class TestErrorServer {
+    private port;
+    private server;
+    private aborted;
+    constructor(port?: number);
+    runServer(): Promise<boolean>;
+    requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any>;
+    static runFromCliArgs(args: string[]): Promise<void>;
+}
+
+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;
+}
+
+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 defaultedCurrentRequestId(defaultValueIfMissing?: string): 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>;
+}
+
+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;
+}
+
+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;
+}
+
+export { AbstractBackgroundManager, type AbstractCronEntry, ApiGatewayAdapterAuthenticationHandler, ApolloFilter, ApolloUtil, Auth0WebTokenManipulator, type AuthorizerFunction, AwsLargePayloadS3SqsSnsBackgroundManager, AwsSqsSnsBackgroundManager, AwsUtil, type BackgroundAwsConfig, type BackgroundConfig, BackgroundDynamoLogTableHandler, type BackgroundEntry, type BackgroundErrorProcessor, type BackgroundExecutionEvent, BackgroundExecutionEventType, type BackgroundExecutionListener, BackgroundHandler, BackgroundHttpAdapterHandler, type BackgroundManagerLike, type BackgroundMetaResponseInternal, BackgroundProcessHandling, type BackgroundProcessLogTableEntry, type BackgroundProcessor, type BackgroundQueueResponseInternal, type BackgroundS3TransactionLoggingConfig, type BackgroundTransactionLog, type BackgroundTransactionLogger, BackgroundValidator, BadGateway, BadRequestError, type BasicAuthToken, BuiltInAuthFilters, BuiltInAuthorizers, BuiltInFilters, BuiltInHandlers, BuiltInTraceIdGenerators, ConflictError, ContextUtil, type CronBackgroundEntry, type CronConfig, CronEpsilonLambdaEventHandler, CronUtil, type DaemonAuthorizerFunction, type DaemonConfig, type DaemonGroupSelectionFunction, DaemonHandler, type DaemonProcessStateList, type DefaultEpsilonApolloContext, type DynamoDbConfig, DynamoEpsilonLambdaEventHandler, EchoProcessor, EpsilonApolloCorsMethod, type EpsilonAuthorizationContext, EpsilonBackgroundProcessError, EpsilonBuildProperties, type EpsilonConfig, EpsilonConfigParser, EpsilonConstants, EpsilonGlobalHandler, type EpsilonInstance, type EpsilonLambdaApolloContextFunctionArgument, type EpsilonLambdaApolloOptions, type EpsilonLambdaEventHandler, type EpsilonLoggerConfig, EpsilonLoggingExtensionProcessor, type EpsilonRouter, EventUtil, type ExtendedAPIGatewayEvent, type ExtendedAuthResponseContext, type FilterChainContext, type FilterFunction, ForbiddenError, GatewayTimeout, type GenericAwsEventHandlerFunction, GenericSnsEpsilonLambdaEventHandler, GenericSqsEpsilonLambdaEventHandler, GoogleWebTokenManipulator, type HandlerFunction, type HttpConfig, type HttpProcessingConfig, type InterApiAwsConfig, type InterApiConfig, type InterApiEntry, InterApiEpsilonLambdaEventHandler, InterApiManager, type InterApiProcessMapping, InterApiUtil, type InternalBackgroundEntry, JwtRatchetLocalWebTokenManipulator, LocalContainerServer, LocalServer, LocalServerCert, LocalWebTokenManipulator, LogAndEnqueueEchoProcessor, LogLevelManipulationFilter, LogMessageBackgroundErrorProcessor, type LoggingTraceIdGenerator, type MappedHttpProcessingConfig, MethodNotAllowedError, MisconfiguredError, NoHandlersFoundError, NoOpProcessor, NotFoundError, NotImplemented, NullReturnedObjectHandling, type OpenApiDocModifications, OpenApiDocModifier, type OpenApiDocument, type OpenApiDocumentComponents, type OpenApiDocumentPath, RatchetCliHandler, RatchetEpsilonCommonInfo, RequestTimeoutError, ResponseUtil, RetryProcessor, type RetryProcessorOptions, type RouteAndParse, type RouteMapping, type RouteValidatorConfig, RouterUtil, RunBackgroundProcessFromCommandLine, RunHandlerAsFilter, S3BackgroundTransactionLogger, type S3Config, S3EpsilonLambdaEventHandler, SampleDelayProcessor, SampleInputValidatedProcessor, type SampleInputValidatedProcessorData, SampleServerComponents, SampleServerStaticFiles, ServiceUnavailable, SingleThreadLocalBackgroundManager, type SnsConfig, type SqsConfig, TestErrorServer, TooManyRequestsError, UnauthorizedError, WebHandler, type WebTokenManipulator, WebV2Handler, YamlCombiner };