@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/types/background/background-dynamo-log-table-handler.d.ts

@@ -0,0 +1,11 @@
+import { BackgroundExecutionListener } from './background-execution-listener';
+import { BackgroundExecutionEvent } from './background-execution-event';
+import { DynamoRatchetLike } from '@bitblit/ratchet-aws';
+export 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>;
+}

package/dist/types/background/background-entry.d.ts

@@ -0,0 +1,4 @@
+export interface BackgroundEntry<T> {
+    type: string;
+    data: T;
+}

package/dist/types/background/background-execution-event-type.d.ts

@@ -0,0 +1,7 @@
+export declare enum BackgroundExecutionEventType {
+    ProcessStarting = "ProcessStarting",
+    DataValidationError = "DataValidationError",
+    ExecutionSuccessfullyComplete = "ExecutionSuccessfullyComplete",
+    ExecutionFailedError = "ExecutionRuntimeError",
+    NoMatchProcessorName = "NoMatchProcessorName"
+}

package/dist/types/background/background-execution-event.d.ts

@@ -0,0 +1,8 @@
+import { BackgroundExecutionEventType } from './background-execution-event-type';
+export interface BackgroundExecutionEvent<T> {
+    type: BackgroundExecutionEventType;
+    guid: string;
+    processorType: string;
+    data: T;
+    errors?: string[];
+}

package/dist/types/background/background-execution-listener.d.ts

@@ -0,0 +1,5 @@
+import { BackgroundExecutionEvent } from './background-execution-event';
+export interface BackgroundExecutionListener<T> {
+    label?: string;
+    onEvent(event: BackgroundExecutionEvent<T>): Promise<void>;
+}

package/dist/types/background/background-handler.d.ts

@@ -0,0 +1,33 @@
+import { Context, ProxyResult, SNSEvent } from 'aws-lambda';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundConfig } from '../config/background/background-config';
+import { InternalBackgroundEntry } from './internal-background-entry';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
+import { BackgroundManagerLike } from './manager/background-manager-like';
+/**
+ * We use a FIFO queue so that 2 different Lambdas don't both work on the same
+ * thing at the same time.
+ */
+export 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(e: InternalBackgroundEntry<any>): Promise<boolean>;
+    getConfig(): BackgroundConfig;
+}

package/dist/types/background/background-http-adapter-handler.d.ts

@@ -0,0 +1,26 @@
+import { Context } from 'aws-lambda';
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event';
+import { BackgroundQueueResponseInternal } from './background-queue-response-internal';
+import { BackgroundConfig } from '../config/background/background-config';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundMetaResponseInternal } from './background-meta-response-internal';
+import { BackgroundTransactionLog } from '../config/background/background-transaction-log';
+import { BackgroundManagerLike } from './manager/background-manager-like';
+/**
+ * We use a FIFO queue so that 2 different Lambdas don't both work on the same
+ * thing at the same time.
+ */
+export 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>;
+}

package/dist/types/background/background-meta-response-internal.d.ts

@@ -0,0 +1,5 @@
+export interface BackgroundMetaResponseInternal {
+    backgroundManagerName: string;
+    currentQueueLength: number;
+    validTypes: string[];
+}

package/dist/types/background/background-process-handling.d.ts

@@ -0,0 +1,4 @@
+export declare enum BackgroundProcessHandling {
+    Queued = "Queued",
+    Immediate = "Immediate"
+}

package/dist/types/background/background-process-log-table-entry.d.ts

@@ -0,0 +1,11 @@
+export interface BackgroundProcessLogTableEntry {
+    env: string;
+    backgroundQueueName: string;
+    requestId: string;
+    guid: string;
+    processTypeName: string;
+    state: string;
+    timestampEpochMs: number;
+    errors?: string[];
+    params?: any;
+}

package/dist/types/background/background-queue-response-internal.d.ts

@@ -0,0 +1,8 @@
+import { BackgroundProcessHandling } from './background-process-handling';
+export interface BackgroundQueueResponseInternal {
+    processHandling: BackgroundProcessHandling;
+    startProcessorRequested: boolean;
+    success: boolean;
+    resultId: string;
+    error: string;
+}

package/dist/types/background/background-validator.d.ts

@@ -0,0 +1,20 @@
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundConfig } from '../config/background/background-config';
+import { BackgroundEntry } from './background-entry';
+import { BackgroundProcessor } from '../config/background/background-processor';
+import { BackgroundAwsConfig } from '../config/background/background-aws-config';
+/**
+ * Handles all submission of work to the background processing system.
+ */
+export 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[];
+}

package/dist/types/background/epsilon-background-process-error.d.ts

@@ -0,0 +1,30 @@
+export 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;
+}

package/dist/types/background/internal-background-entry.d.ts

@@ -0,0 +1,7 @@
+import { BackgroundEntry } from './background-entry';
+export interface InternalBackgroundEntry<T> extends BackgroundEntry<T> {
+    guid: string;
+    createdEpochMS: number;
+    traceId: string;
+    traceDepth: number;
+}

package/dist/types/background/manager/abstract-background-manager.d.ts

@@ -0,0 +1,26 @@
+import { BackgroundEntry } from '../background-entry';
+import { InternalBackgroundEntry } from '../internal-background-entry';
+import { BackgroundManagerLike } from './background-manager-like';
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+export 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): 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;
+}

package/dist/types/background/manager/aws-sqs-sns-background-manager.d.ts

@@ -0,0 +1,30 @@
+import { GetQueueAttributesCommandOutput, SQSClient } from '@aws-sdk/client-sqs';
+import { BackgroundEntry } from '../background-entry';
+import { BackgroundAwsConfig } from '../../config/background/background-aws-config';
+import { InternalBackgroundEntry } from '../internal-background-entry';
+import { AbstractBackgroundManager } from './abstract-background-manager';
+import { SNSClient } from '@aws-sdk/client-sns';
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+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/dist/types/background/manager/background-manager-like.d.ts

@@ -0,0 +1,24 @@
+import { BackgroundEntry } from '../background-entry';
+import { InternalBackgroundEntry } from '../internal-background-entry';
+import { Subject } from 'rxjs';
+/**
+ * Classes implementing this interface handle all submission of work to the background processing system.
+ *
+ * Note that these do NOT validate the input, they just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+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/dist/types/background/manager/single-thread-local-background-manager.d.ts

@@ -0,0 +1,22 @@
+import { Subject } from 'rxjs';
+import { BackgroundEntry } from '../background-entry';
+import { InternalBackgroundEntry } from '../internal-background-entry';
+import { AbstractBackgroundManager } from './abstract-background-manager';
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+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/dist/types/background/s3-background-transaction-logger.d.ts

@@ -0,0 +1,17 @@
+import { BackgroundTransactionLogger } from '../config/background/background-transaction-logger';
+import { BackgroundTransactionLog } from '../config/background/background-transaction-log';
+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/dist/types/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/dist/types/built-in/background/echo-processor.d.ts

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

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

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

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

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

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

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

package/dist/types/built-in/background/retry-processor.d.ts

@@ -0,0 +1,16 @@
+import { BackgroundProcessor } from '../../config/background/background-processor';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+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/dist/types/built-in/background/sample-delay-processor.d.ts

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

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

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

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

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

package/dist/types/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/dist/types/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';
+export interface DaemonAuthorizerFunction {
+    (evt: ExtendedAPIGatewayEvent, proc: DaemonProcessState): Promise<boolean>;
+}

package/dist/types/built-in/daemon/daemon-config.d.ts

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

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

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

package/dist/types/built-in/daemon/daemon-handler.d.ts

@@ -0,0 +1,22 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws';
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function';
+import { DaemonLike } from '@bitblit/ratchet-aws';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
+import { DaemonProcessStateList } from './daemon-process-state-list';
+import { DaemonConfig } from './daemon-config';
+/**
+ * A helper class to simplify adding Ratchet "Daemon" handling to your application
+ */
+export declare class DaemonHandler {
+    private daemon;
+    private inConfig?;
+    static readonly ALLOW_EVERYTHING_AUTHORIZER: DaemonAuthorizerFunction;
+    private config;
+    /**
+     * Initialize the Router
+     */
+    constructor(daemon: DaemonLike, inConfig?: DaemonConfig);
+    fetchDaemonStatusByPublicToken(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState>;
+    fetchDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState>;
+    listDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessStateList>;
+}

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

@@ -0,0 +1,8 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws';
+/**
+ * Wrapper for future pagination capability
+ */
+export interface DaemonProcessStateList {
+    results: DaemonProcessState[];
+    nextToken: string;
+}

package/dist/types/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';
+import { FilterChainContext } from '../../config/http/filter-chain-context';
+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/dist/types/built-in/http/built-in-auth-filters.d.ts

@@ -0,0 +1,9 @@
+import { FilterChainContext } from '../../config/http/filter-chain-context';
+import { WebTokenManipulator } from '../../http/auth/web-token-manipulator';
+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/dist/types/built-in/http/built-in-authorizers.d.ts

@@ -0,0 +1,8 @@
+import { APIGatewayEvent } from 'aws-lambda';
+import { RouteMapping } from '../../http/route/route-mapping';
+import { EpsilonAuthorizationContext } from '../../config/http/epsilon-authorization-context';
+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/dist/types/built-in/http/built-in-filters.d.ts

@@ -0,0 +1,25 @@
+import { FilterFunction } from '../../config/http/filter-function';
+import { FilterChainContext } from '../../config/http/filter-chain-context';
+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/dist/types/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';
+import { EpsilonRouter } from '../../http/route/epsilon-router';
+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/dist/types/built-in/http/log-level-manipulation-filter.d.ts

@@ -0,0 +1,9 @@
+import { FilterChainContext } from '../../config/http/filter-chain-context';
+/**
+ * This only works because Node is single threaded...
+ */
+export declare class LogLevelManipulationFilter {
+    private static LOG_LEVEL_BEFORE_CHANGE;
+    static setLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;
+    static clearLogLevelForTransaction(fCtx: FilterChainContext): Promise<boolean>;
+}

package/dist/types/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';
+import { RouteAndParse } from '../../http/web-handler';
+import { NullReturnedObjectHandling } from '../../config/http/null-returned-object-handling';
+import { FilterFunction } from '../../config/http/filter-function';
+import { FilterChainContext } from '../../config/http/filter-chain-context';
+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/dist/types/cli-bootstrap/epsilon-run-background-process-from-command-line-dry-run.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/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/dist/types/config/background/background-config.d.ts

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

package/dist/types/config/background/background-error-processor.d.ts

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

package/dist/types/config/background/background-processor.d.ts

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

package/dist/types/config/background/background-transaction-log.d.ts

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