@bitblit/ratchet-epsilon-common 4.0.85-alpha

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

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

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

@@ -0,0 +1,15 @@
+import { AbstractCronEntry } from './abstract-cron-entry';
+/**
+  of 2020-04-30, my recommendation is that CRON should be used ONLY to fire
+ * off Background tasks (this makes your CRON stuff easier to debug since it can
+ * be called from anywhere, not just CRON, and also makes sure that your processor
+ * gets the full 15 minutes if necessary)
+ *
+ * This simplifies doing that - you can basically just configure the set of
+ * constraints, and the background task to fire off if the constraints match.
+ */
+export interface CronBackgroundEntry extends AbstractCronEntry {
+    backgroundTaskType: string;
+    fireImmediate: boolean;
+    data?: any;
+}

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

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

package/dist/types/config/dynamo-db-config.d.ts

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

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

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

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

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

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

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

package/dist/types/config/http/authorizer-function.d.ts

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

package/dist/types/config/http/epsilon-authorization-context.d.ts

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

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

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

package/dist/types/config/http/filter-chain-context.d.ts

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

package/dist/types/config/http/filter-function.d.ts

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

package/dist/types/config/http/handler-function.d.ts

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

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

@@ -0,0 +1,15 @@
+import { HandlerFunction } from './handler-function';
+import { AuthorizerFunction } from './authorizer-function';
+import { HttpProcessingConfig } from './http-processing-config';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { MappedHttpProcessingConfig } from './mapped-http-processing-config';
+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/dist/types/config/http/http-processing-config.d.ts

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

package/dist/types/config/http/mapped-http-processing-config.d.ts

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

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

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

package/dist/types/config/inter-api/inter-api-aws-config.d.ts

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

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

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

package/dist/types/config/inter-api/inter-api-process-mapping.d.ts

@@ -0,0 +1,11 @@
+/**
+ * When an event matching the source and type is received, the listed background types will be
+ * enqueued with the data from the inter-api block being treated as the data block of the background
+ * task
+ */
+export interface InterApiProcessMapping {
+    sourceRegex: string;
+    typeRegex: string;
+    disabled: boolean;
+    backgroundProcessTypes: string[];
+}

package/dist/types/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/dist/types/config/open-api/open-api-document-components.d.ts

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

package/dist/types/config/open-api/open-api-document-path.d.ts

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

package/dist/types/config/open-api/open-api-document.d.ts

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

package/dist/types/config/s3-config.d.ts

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

package/dist/types/config/sns-config.d.ts

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

package/dist/types/epsilon-build-properties.d.ts

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

package/dist/types/epsilon-constants.d.ts

@@ -0,0 +1,16 @@
+import { EpsilonGlobalHandler } from './epsilon-global-handler';
+export 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();
+}

package/dist/types/epsilon-global-handler.d.ts

@@ -0,0 +1,23 @@
+import { Context, ProxyResult } from 'aws-lambda';
+import { BackgroundEntry } from './background/background-entry';
+import { EpsilonInstance } from './epsilon-instance';
+import { LoggerOptions } from '@bitblit/ratchet-common';
+/**
+ * This class functions as the adapter from a default Lambda function to the handlers exposed via Epsilon
+ */
+export 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>;
+}

package/dist/types/epsilon-instance.d.ts

@@ -0,0 +1,19 @@
+import { EpsilonConfig } from './config/epsilon-config';
+import { WebHandler } from './http/web-handler';
+import { BackgroundHandler } from './background/background-handler';
+import { OpenApiDocument } from './config/open-api/open-api-document';
+import { ModelValidator } from '@bitblit/ratchet-misc';
+import { BackgroundManagerLike } from './background/manager/background-manager-like';
+/**
+ * This interface just wraps up everything that gets created by the config parsing process so that
+ * I can hand it in a neat package to EpsilonGlobalHandler, rather than passing in a bunch of
+ * params on the constructor
+ */
+export interface EpsilonInstance {
+    config: EpsilonConfig;
+    parsedOpenApiDoc: OpenApiDocument;
+    modelValidator: ModelValidator;
+    webHandler: WebHandler;
+    backgroundHandler: BackgroundHandler;
+    backgroundManager: BackgroundManagerLike;
+}

package/dist/types/epsilon-logging-extension-processor.d.ts

@@ -0,0 +1,5 @@
+import { LogMessage, LogMessageProcessor } from '@bitblit/ratchet-common';
+export declare class EpsilonLoggingExtensionProcessor implements LogMessageProcessor {
+    process(msg: LogMessage): LogMessage;
+    label(): string;
+}

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

@@ -0,0 +1,18 @@
+import { Callback, Context, CustomAuthorizerEvent } from 'aws-lambda';
+/**
+ * This class is to simplify if the user wants to use a AWS Gateway authorizer in conjunction with Epsilon
+ */
+export declare class ApiGatewayAdapterAuthenticationHandler {
+    private webTokenManipulator;
+    constructor(issuer: string, encryptionKeys: string);
+    /**
+     * This is the default authorizer - parses the incoming JWT token and sticks it
+     * into context (or blocks if none/invalid found)
+     * @param event
+     * @param {Context} context
+     * @param {Callback} callback
+     */
+    lambdaHandler(event: CustomAuthorizerEvent, context: Context, callback: Callback): void;
+    private createPolicy;
+    static extractTokenStringFromAuthorizerEvent(event: CustomAuthorizerEvent): string;
+}

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

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

package/dist/types/http/auth/basic-auth-token.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Simple decoding of a Basic Authorization header
+ */
+export interface BasicAuthToken {
+    username: string;
+    password: string;
+}

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

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

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

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

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

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

package/dist/types/http/auth/web-token-manipulator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Service for handling auth tokens
+ */
+import { JwtTokenBase } from '@bitblit/ratchet-common';
+export interface WebTokenManipulator<T extends JwtTokenBase> {
+    extractTokenFromAuthorizationHeader(header: string): Promise<T>;
+}

package/dist/types/http/error/bad-gateway.d.ts

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

package/dist/types/http/error/bad-request-error.d.ts

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

package/dist/types/http/error/conflict-error.d.ts

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

package/dist/types/http/error/epsilon-http-error.d.ts

@@ -0,0 +1,41 @@
+export declare class EpsilonHttpError<T = void> extends Error {
+    private static readonly EPSILON_HTTP_ERROR_FLAG_KEY;
+    private _httpStatusCode;
+    private _errors;
+    private _detailErrorCode;
+    private _endUserErrors;
+    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[]): EpsilonHttpError<T>;
+    withHttpStatusCode(httpStatusCode: number): EpsilonHttpError<T>;
+    withErrors(errors: string[]): EpsilonHttpError<T>;
+    withDetailErrorCode(detailErrorCode: number): EpsilonHttpError<T>;
+    withEndUserErrors(endUserErrors: string[]): EpsilonHttpError<T>;
+    withDetails(details: T): EpsilonHttpError<T>;
+    withRequestId(requestId: string): EpsilonHttpError<T>;
+    withWrappedError(err: Error): EpsilonHttpError<T>;
+    isWrappedError(): boolean;
+    static wrapError<T = void>(err: Error): EpsilonHttpError<T>;
+    static objectIsEpsilonHttpError(obj: any): boolean;
+    get httpStatusCode(): number;
+    get errors(): string[];
+    get detailErrorCode(): number;
+    get endUserErrors(): string[];
+    get details(): T;
+    get requestId(): string;
+    get wrappedError(): Error;
+    set httpStatusCode(value: number);
+    set errors(value: string[]);
+    set detailErrorCode(value: number);
+    set endUserErrors(value: string[]);
+    set details(value: T);
+    set requestId(value: string);
+    set wrappedError(value: Error);
+    static errorIsX0x(errIn: Error, xClass: number): boolean;
+    static errorIs40x(err: Error): boolean;
+    static errorIs50x(err: Error): boolean;
+}

package/dist/types/http/error/forbidden-error.d.ts

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

package/dist/types/http/error/gateway-timeout.d.ts

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

package/dist/types/http/error/method-not-allowed-error.d.ts

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

package/dist/types/http/error/misconfigured-error.d.ts

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

package/dist/types/http/error/not-found-error.d.ts

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

package/dist/types/http/error/not-implemented.d.ts

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

package/dist/types/http/error/request-timeout-error.d.ts

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

package/dist/types/http/error/service-unavailable.d.ts

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

package/dist/types/http/error/too-many-requests-error.d.ts

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

package/dist/types/http/error/unauthorized-error.d.ts

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