@bymax-one/nest-core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,550 @@
+import * as _nestjs_common from '@nestjs/common';
+import { DynamicModule, ExceptionFilter, ArgumentsHost, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { Observable } from 'rxjs';
+
+/**
+ * @fileoverview Public configuration surface for `BymaxCoreModule` plus the
+ * resolution pipeline that merges consumer options over the documented defaults
+ * and deep-freezes the result. Every feature reads its effective configuration
+ * from the resolved snapshot, never from the raw consumer input.
+ * @layer Config
+ */
+/** Error-envelope exception-filter configuration. */
+interface EnvelopeOptions {
+    /** Register the global exception filter. Default: `true`. */
+    enabled?: boolean;
+    /**
+     * Include the original message and stack of unknown errors in the envelope
+     * details. Never enable in production. Default: `false`.
+     */
+    exposeInternals?: boolean;
+}
+/** Request-timing interceptor configuration. */
+interface TimingOptions {
+    /** Register the timing interceptor. Default: `true`. */
+    enabled?: boolean;
+    /** Samples above this threshold are flagged as slow. No default (unset). */
+    slowRequestThresholdMs?: number;
+}
+/** Liveness and readiness endpoint configuration. */
+interface HealthOptions {
+    /** Register the health controller. Default: `true`. */
+    enabled?: boolean;
+    /** Route prefix for the health endpoints. Default: `'health'`. */
+    path?: string;
+    /** Per-indicator timeout before a check is reported as down. Default: `5000`. */
+    indicatorTimeoutMs?: number;
+}
+/** Prometheus metrics endpoint configuration. */
+interface MetricsOptions {
+    /** Register the metrics controller. Default: `false`. */
+    enabled?: boolean;
+    /** Route for the metrics endpoint. Default: `'metrics'`. */
+    path?: string;
+    /** Static labels added to every metric. Default: `{}`. */
+    defaultLabels?: Record<string, string>;
+    /** Collect `prom-client` default process metrics. Default: `true`. */
+    collectDefaultMetrics?: boolean;
+}
+/**
+ * Consumer-facing options for `BymaxCoreModule.forRoot` / `forRootAsync`. Every
+ * block is optional; omitted values fall back to the documented defaults.
+ */
+interface BymaxCoreModuleOptions {
+    /** Error-envelope exception filter. Default: enabled. */
+    envelope?: EnvelopeOptions;
+    /** Request timing interceptor. Default: enabled. */
+    timing?: TimingOptions;
+    /** Liveness and readiness endpoints. Default: enabled. */
+    health?: HealthOptions;
+    /** Prometheus metrics endpoint. Default: disabled. */
+    metrics?: MetricsOptions;
+}
+/** Fully-resolved envelope options. */
+interface ResolvedEnvelopeOptions {
+    enabled: boolean;
+    exposeInternals: boolean;
+}
+/** Fully-resolved timing options. `slowRequestThresholdMs` stays absent when unset. */
+interface ResolvedTimingOptions {
+    enabled: boolean;
+    slowRequestThresholdMs?: number;
+}
+/** Fully-resolved health options. */
+interface ResolvedHealthOptions {
+    enabled: boolean;
+    path: string;
+    indicatorTimeoutMs: number;
+}
+/** Fully-resolved metrics options. */
+interface ResolvedMetricsOptions {
+    enabled: boolean;
+    path: string;
+    collectDefaultMetrics: boolean;
+    defaultLabels: Record<string, string>;
+}
+/**
+ * The effective, defaults-applied configuration exposed under
+ * `BYMAX_CORE_OPTIONS`. Fields with a documented default are always present;
+ * the only optional field is `timing.slowRequestThresholdMs`, which has no
+ * default and is absent unless the consumer sets it.
+ */
+interface ResolvedCoreOptions {
+    envelope: ResolvedEnvelopeOptions;
+    timing: ResolvedTimingOptions;
+    health: ResolvedHealthOptions;
+    metrics: ResolvedMetricsOptions;
+}
+
+/** Non-option extras accepted by `forRoot` / `forRootAsync`. */
+interface BymaxCoreModuleExtras {
+    /** Register the module globally. Default: `true`. */
+    isGlobal?: boolean;
+}
+/**
+ * Builder-generated base. `BUILDER_OPTIONS_TOKEN` carries the RAW consumer
+ * options and stays internal; the public, defaults-applied snapshot is exposed
+ * separately under {@link BYMAX_CORE_OPTIONS}. `isGlobal` (default `true`) maps
+ * to `DynamicModule.global`, replacing a manual `@Global()` decorator.
+ */
+declare const BymaxCoreModuleBase: _nestjs_common.ConfigurableModuleCls<BymaxCoreModuleOptions, "forRoot", "create", BymaxCoreModuleExtras>;
+declare const OPTIONS_TYPE: BymaxCoreModuleOptions & Partial<BymaxCoreModuleExtras>;
+declare const ASYNC_OPTIONS_TYPE: _nestjs_common.ConfigurableModuleAsyncOptions<BymaxCoreModuleOptions, "create"> & Partial<BymaxCoreModuleExtras>;
+/**
+ * `BymaxCoreModule`, the application foundation module for NestJS 11.
+ */
+declare class BymaxCoreModule extends BymaxCoreModuleBase {
+    /**
+     * Register the module synchronously. Options are known now, so disabled
+     * features are omitted from the providers and controllers arrays and the
+     * resolved snapshot is provided under {@link BYMAX_CORE_OPTIONS}.
+     *
+     * @param options - Core options plus the optional `isGlobal` extra. Omit for
+     *   all documented defaults.
+     * @returns The configured `DynamicModule`.
+     * @example
+     *   BymaxCoreModule.forRoot({ metrics: { enabled: true } })
+     */
+    static forRoot(options?: typeof OPTIONS_TYPE): DynamicModule;
+    /**
+     * Register the module asynchronously. The resolved options are produced by
+     * the consumer's factory and normalized under {@link BYMAX_CORE_OPTIONS}.
+     * Because those options are unknown when the module is defined, the pipeline
+     * slots register unconditionally and gate at runtime with transparent
+     * pass-throughs. The health controller cannot register conditionally either,
+     * since its route metadata is fixed before the async options resolve: it is
+     * always registered at the default health path, and its handlers guard
+     * every request against the resolved options being disabled or requesting a
+     * different path, throwing a descriptive configuration error in either case.
+     * The metrics controller follows the same mechanism at the default metrics
+     * path; the `BYMAX_METRICS_REGISTRY` factory gates on the resolved options and
+     * resolves to a guarded placeholder when metrics are disabled, so the optional
+     * peer `prom-client` is never loaded unless metrics are actually enabled.
+     *
+     * @param options - Async options (factory + inject + imports, or class).
+     * @returns The configured `DynamicModule`.
+     * @example
+     *   BymaxCoreModule.forRootAsync({ inject: [Config], useFactory: (c) => ({ ... }) })
+     */
+    static forRootAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
+}
+
+/**
+ * @fileoverview Dependency-injection tokens for `@bymax-one/nest-core`.
+ * Every token is a `Symbol`, so the container never collides with a consumer's
+ * string tokens and the public contracts stay explicit at every injection site.
+ * @layer Constants
+ */
+/**
+ * Provide the resolved, deep-frozen {@link ResolvedCoreOptions} snapshot.
+ * Consumers inject this to read the effective configuration after defaults.
+ */
+declare const BYMAX_CORE_OPTIONS: unique symbol;
+/**
+ * Provide the `ICorrelationIdProvider` used to stamp the current correlation id
+ * onto error envelopes. Defaults to a no-op that returns `undefined`.
+ */
+declare const BYMAX_CORRELATION_PROVIDER: unique symbol;
+/**
+ * Provide the `ITimingSink` that receives one sample per completed request.
+ * Defaults to a no-op sink.
+ */
+declare const BYMAX_TIMING_SINK: unique symbol;
+/**
+ * Provide the array of health indicators aggregated by the health endpoints.
+ * Defaults to an empty array.
+ */
+declare const BYMAX_HEALTH_INDICATORS: unique symbol;
+/**
+ * Provide the `prom-client` `Registry` backing the metrics endpoint. Bound
+ * lazily and only when the metrics feature is enabled.
+ */
+declare const BYMAX_METRICS_REGISTRY: unique symbol;
+
+/**
+ * @fileoverview Correlation-id contract consumed by the error envelope. The
+ * filter resolves this provider to stamp the current request's correlation id
+ * onto every error response. The default binding is a no-op; any implementation
+ * (for example the AsyncLocalStorage-based log context of `@bymax-one/nest-logger`)
+ * plugs in through the `BYMAX_CORRELATION_PROVIDER` token with no hard coupling.
+ * @layer Contract
+ */
+/**
+ * Resolve the correlation id for the current execution context.
+ */
+interface ICorrelationIdProvider {
+    /**
+     * Return the correlation id for the current execution context.
+     *
+     * @returns The correlation id, or `undefined` when none is bound.
+     */
+    getCorrelationId(): string | undefined;
+}
+
+/**
+ * Neutral view of the current request handed to {@link BymaxExceptionFilter}
+ * mappers and to the {@link BymaxExceptionFilter.onUnexpectedError} seam. It
+ * exposes only the framework-agnostic surface (path, method, correlation id).
+ */
+interface FilterErrorContext {
+    /** HTTP method, read through the adapter (Express and Fastify neutral). */
+    readonly method: string;
+    /** Request URL path, read through the adapter (Express and Fastify neutral). */
+    readonly path: string;
+    /** Correlation id for the current request; absent when no provider resolves one. */
+    readonly correlationId?: string;
+}
+/**
+ * Global exception filter emitting the stable error envelope. Registered as the
+ * outermost `APP_FILTER` when the envelope feature is enabled, so it formats
+ * every error that escapes a handler, including those thrown by other filters.
+ */
+declare class BymaxExceptionFilter implements ExceptionFilter {
+    private readonly options;
+    private readonly adapterHost;
+    /** Clock used to stamp the envelope timestamp; overridable in tests via fake timers. */
+    private readonly now;
+    /** The resolved correlation provider, or the no-op fallback when none is bound. */
+    private readonly correlation;
+    /**
+     * @param options - Resolved core options; drives the `exposeInternals` switch.
+     * @param correlation - Provider resolving the current request's correlation id.
+     *   Injected with `@Optional()`: `BymaxCoreModule` binds no local default for
+     *   this token, so a consumer's own `BYMAX_CORRELATION_PROVIDER` binding
+     *   (from their own, globally-visible module) is not shadowed by one; when
+     *   nothing is bound, this falls back to a no-op that omits `correlationId`.
+     * @param adapterHost - Host of the live HTTP adapter, resolved lazily per catch.
+     */
+    constructor(options: ResolvedCoreOptions, correlation: ICorrelationIdProvider | undefined, adapterHost: HttpAdapterHost);
+    /**
+     * Format the exception into the stable envelope and reply with it.
+     *
+     * Non-HTTP execution contexts (GraphQL, RPC) are out of scope and are
+     * rethrown untouched so their own error handling applies.
+     *
+     * @param exception - The error that escaped the handler.
+     * @param host - The arguments host for the current execution context.
+     */
+    catch(exception: unknown, host: ArgumentsHost): void;
+    /**
+     * Select the mapping rule for the exception and build its envelope. An
+     * unknown error is handed to the observability seam before it collapses, so
+     * an integration can record the original error with the request context.
+     *
+     * @param exception - The error that escaped the handler.
+     * @param context - The neutral request context.
+     * @returns The formatted envelope.
+     */
+    private buildEnvelope;
+    /**
+     * Map an `HttpException` to the envelope. Explicit domain codes pass through;
+     * the validation shape becomes `BYMAX_VALIDATION_FAILED` with structured
+     * details; everything else derives its code from the status.
+     *
+     * @param exception - The HTTP exception to format.
+     * @param context - The neutral request context.
+     * @returns The formatted envelope.
+     */
+    private mapHttpException;
+    /**
+     * Collapse an unknown error to the fixed, production-safe 500. The original
+     * error is never serialized unless `exposeInternals` is on, in which case its
+     * message and stack are attached to `details` (development only).
+     *
+     * @param exception - The original thrown value.
+     * @param context - The neutral request context.
+     * @returns The generic internal-error envelope.
+     */
+    private mapUnknown;
+    /**
+     * Assemble the envelope through the pure builder, threading the shared clock
+     * and omitting absent optional details.
+     *
+     * @param statusCode - HTTP status for the envelope.
+     * @param code - Stable machine-readable code.
+     * @param message - Human-readable, end-user-safe message.
+     * @param context - The neutral request context.
+     * @param details - Optional structured context; omitted when absent.
+     * @returns The formatted envelope.
+     */
+    private toEnvelope;
+    /**
+     * Observability seam invoked for every unexpected (non-`HttpException`) error
+     * before it collapses to the generic 500. The base implementation is a no-op:
+     * this library owns no logger. An integration (for example
+     * `@bymax-one/nest-logger`) subclasses the filter and overrides this to record
+     * the original error with the current request context and correlation id.
+     * Overrides must never throw and must never write to the response.
+     *
+     * @param _error - The original thrown value.
+     * @param _context - The neutral request context.
+     */
+    protected onUnexpectedError(_error: unknown, _context: FilterErrorContext): void;
+}
+
+/**
+ * @fileoverview The stable error-envelope contract and its pure builder. Every
+ * error leaving a `@bymax-one/nest-core` application is serialized into this
+ * shape, which is versioned with the package: adding an optional field is a
+ * minor release, changing or removing a field is a major release. The builder
+ * omits absent optional fields entirely so they never surface as `undefined`
+ * keys in the serialized JSON.
+ * @layer DTO
+ */
+/**
+ * Structured error context attached to an envelope. Validation failures use the
+ * array form (one entry per violation); the development-only internals dump uses
+ * the object form. The contract keeps it deliberately open: array or object.
+ */
+type ErrorDetails = readonly unknown[] | Readonly<Record<string, unknown>>;
+/**
+ * The exact shape of every error response. Field presence is part of the
+ * contract:
+ *
+ * - `statusCode`, `code`, `message`, `timestamp`, and `path` are always present.
+ * - `details` is present only when structured context exists (validation issues
+ *   or, in development, the collapsed internal error).
+ * - `correlationId` is present only when a correlation provider resolves an id.
+ */
+interface ErrorEnvelope {
+    /** HTTP status code of the response. Always present. */
+    readonly statusCode: number;
+    /** Stable machine-readable code from the `BYMAX_*` catalog or a passed-through domain code. Always present. */
+    readonly code: string;
+    /** Human-readable message, safe to show end users. Always present. */
+    readonly message: string;
+    /** Structured context, such as validation issues. Present only when it exists. */
+    readonly details?: ErrorDetails;
+    /** Correlation id for the current request. Present only when a provider resolves one. */
+    readonly correlationId?: string;
+    /** ISO 8601 instant the error was formatted. Always present. */
+    readonly timestamp: string;
+    /** Request URL path. Always present. */
+    readonly path: string;
+}
+/**
+ * Primitive inputs the builder assembles into an {@link ErrorEnvelope}. The
+ * clock is injected as `now` so callers (and tests) control the timestamp
+ * without patching global time.
+ */
+interface BuildErrorEnvelopeInput {
+    /** HTTP status code of the response. */
+    readonly statusCode: number;
+    /** Stable machine-readable code. */
+    readonly code: string;
+    /** Human-readable, end-user-safe message. */
+    readonly message: string;
+    /** Structured context. Omit when there is none; never pass `undefined`. */
+    readonly details?: ErrorDetails;
+    /** Correlation id. Omit when none is bound; never pass `undefined`. */
+    readonly correlationId?: string;
+    /** Request URL path. */
+    readonly path: string;
+    /** Injectable clock; called once to stamp the ISO 8601 timestamp. */
+    readonly now: () => Date;
+}
+/**
+ * Assemble an {@link ErrorEnvelope} from primitive inputs.
+ *
+ * Pure: the only side effect is calling `now()` once for the timestamp. Absent
+ * optional fields (`details`, `correlationId`) are omitted from the returned
+ * object rather than set to `undefined`, so `JSON.stringify` never emits them.
+ *
+ * @param input - The envelope fields plus the injectable clock.
+ * @returns A fully-formed envelope with no `undefined`-valued keys.
+ */
+declare function buildErrorEnvelope(input: BuildErrorEnvelopeInput): ErrorEnvelope;
+
+/**
+ * @fileoverview Monotonic clock seam for request-timing duration math. Wall-clock
+ * date sources (`Date.now()`, `new Date()`) are banned for measuring elapsed
+ * time anywhere in this feature: the system clock can jump backward or forward
+ * (NTP adjustments, leap seconds, manual changes), which would corrupt a
+ * duration measurement. Every elapsed-time computation in `src/timing/` reads
+ * from this seam instead, so the interceptor stays testable with a stub clock
+ * that advances by controlled amounts.
+ * @layer Utility
+ */
+/** A source of monotonically increasing timestamps, in milliseconds. */
+interface MonotonicClock {
+    /**
+     * Read the current monotonic timestamp.
+     *
+     * @returns Milliseconds from a monotonic, ever-increasing source. Only
+     *   differences between two calls are meaningful; the absolute value carries
+     *   no calendar significance.
+     */
+    now(): number;
+}
+
+/**
+ * @fileoverview Request-timing contracts. The timing interceptor emits one
+ * {@link RequestTimingSample} per completed request to the bound
+ * {@link ITimingSink}. The default sink is a no-op; consumers plug in a logger
+ * bridge or the metrics bridge through the `BYMAX_TIMING_SINK` token.
+ * @layer Contract
+ */
+/**
+ * A single request-timing measurement. The route template (not the raw URL) is
+ * used to keep cardinality bounded for downstream metric sinks.
+ */
+interface RequestTimingSample {
+    /** HTTP method, for example `"GET"`. */
+    method: string;
+    /** Route template, for example `"/invoices/:id"` (not the raw URL). */
+    route: string;
+    /** Final HTTP status, including error statuses. */
+    statusCode: number;
+    /** Wall-clock duration from a monotonic clock, in milliseconds. */
+    durationMs: number;
+    /** Whether the sample exceeded the configured slow-request threshold. */
+    slow: boolean;
+}
+/**
+ * Receive request-timing samples. Implementations must never throw: a sink
+ * failure is caught and silenced by the interceptor so timing never breaks a
+ * request.
+ */
+interface ITimingSink {
+    /**
+     * Record one sample for a completed request.
+     *
+     * @param sample - The timing sample to record.
+     */
+    record(sample: RequestTimingSample): void;
+}
+
+/**
+ * Request-timing interceptor. Registered as the `APP_INTERCEPTOR` when the
+ * timing feature is enabled, on both the sync and async registration paths.
+ * Non-HTTP execution contexts (GraphQL, RPC) pass through untouched: this
+ * feature is HTTP-first, matching the exception filter's documented scope.
+ */
+declare class TimingInterceptor implements NestInterceptor {
+    private readonly options;
+    private readonly clock;
+    /** The bound timing sink, or the no-op fallback when none resolves. */
+    private readonly sink;
+    /**
+     * @param options - Resolved core options; supplies `slowRequestThresholdMs`.
+     * @param sink - The bound timing sink; its `record` failures are swallowed.
+     *   Injected with `@Optional()`: `BymaxCoreModule` binds no local default for
+     *   this token on the sync path when the metrics bridge is not registered, so
+     *   a consumer's own `BYMAX_TIMING_SINK` binding is not shadowed by one; when
+     *   nothing resolves, this falls back to a no-op sink.
+     * @param clock - Monotonic clock seam; defaults to `performance.now()`, and
+     *   is bound explicitly through {@link BYMAX_TIMING_CLOCK} so tests inject a
+     *   stub advancing by controlled amounts.
+     */
+    constructor(options: ResolvedCoreOptions, sink: ITimingSink | undefined, clock?: MonotonicClock);
+    /**
+     * Measure the handler chain and record exactly one sample per completed
+     * request, on the success path and on the error path alike.
+     *
+     * @param context - The execution context of the current request.
+     * @param next - The next handler in the chain.
+     * @returns The downstream response stream, unmodified beyond the measurement.
+     */
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    /**
+     * Read the final status code from the response object on the success path.
+     *
+     * @param context - The execution context of the current request.
+     * @returns The response's status code, or the default success status when absent.
+     */
+    private readSuccessStatus;
+    /**
+     * Derive the final status code for an error that escaped the handler.
+     *
+     * @param error - The error propagated by the handler chain.
+     * @returns The `HttpException` status, or the generic 500 for anything else.
+     */
+    private readErrorStatus;
+    /**
+     * Build the sample, compute the slow flag, and deliver it to the sink inside
+     * a try/catch that silences any failure: a throwing sink must never affect
+     * the request it is observing.
+     *
+     * @param method - HTTP method of the request.
+     * @param route - Route template of the request.
+     * @param statusCode - Final status code, success or error.
+     * @param start - Monotonic start timestamp captured before the handler ran.
+     */
+    private recordSample;
+}
+
+/**
+ * @fileoverview Stable `BYMAX_*` error-code catalog and HTTP-status derivation.
+ * These codes are the machine-readable half of the error envelope contract and
+ * are shared by the exception filter and the cursor codec, so they live in the
+ * foundation rather than in any single feature.
+ * @layer Constants
+ */
+/** Generic malformed-request code for HTTP 400. */
+declare const BYMAX_BAD_REQUEST = "BYMAX_BAD_REQUEST";
+/** Code emitted when a request fails structured validation. */
+declare const BYMAX_VALIDATION_FAILED = "BYMAX_VALIDATION_FAILED";
+/** Missing or invalid authentication code for HTTP 401. */
+declare const BYMAX_UNAUTHORIZED = "BYMAX_UNAUTHORIZED";
+/** Authenticated-but-not-allowed code for HTTP 403. */
+declare const BYMAX_FORBIDDEN = "BYMAX_FORBIDDEN";
+/** Unknown-resource code for HTTP 404. */
+declare const BYMAX_NOT_FOUND = "BYMAX_NOT_FOUND";
+/** State-conflict code for HTTP 409. */
+declare const BYMAX_CONFLICT = "BYMAX_CONFLICT";
+/** Oversized-payload code for HTTP 413. */
+declare const BYMAX_PAYLOAD_TOO_LARGE = "BYMAX_PAYLOAD_TOO_LARGE";
+/** Unsupported-content-type code for HTTP 415. */
+declare const BYMAX_UNSUPPORTED_MEDIA_TYPE = "BYMAX_UNSUPPORTED_MEDIA_TYPE";
+/** Semantically-invalid-entity code for HTTP 422. */
+declare const BYMAX_UNPROCESSABLE_ENTITY = "BYMAX_UNPROCESSABLE_ENTITY";
+/** Rate-limit code for HTTP 429. */
+declare const BYMAX_TOO_MANY_REQUESTS = "BYMAX_TOO_MANY_REQUESTS";
+/** Generic client-error fallback for any uncatalogued 4xx status. */
+declare const BYMAX_CLIENT_ERROR = "BYMAX_CLIENT_ERROR";
+/** Internal-failure code for HTTP 500 and any uncatalogued non-4xx status. */
+declare const BYMAX_INTERNAL_ERROR = "BYMAX_INTERNAL_ERROR";
+/** Unimplemented-handler code for HTTP 501. */
+declare const BYMAX_NOT_IMPLEMENTED = "BYMAX_NOT_IMPLEMENTED";
+/** Upstream-failure code for HTTP 502. */
+declare const BYMAX_BAD_GATEWAY = "BYMAX_BAD_GATEWAY";
+/** Temporary-unavailability code for HTTP 503. */
+declare const BYMAX_SERVICE_UNAVAILABLE = "BYMAX_SERVICE_UNAVAILABLE";
+/** Upstream-timeout code for HTTP 504. */
+declare const BYMAX_GATEWAY_TIMEOUT = "BYMAX_GATEWAY_TIMEOUT";
+/**
+ * Derive the stable `BYMAX_*` code for an HTTP status when a thrown exception
+ * carries no explicit `code`.
+ *
+ * The validation code is never derived here: whether a 400 is a validation
+ * failure is a shape decision made by the exception filter, so status 400
+ * resolves to {@link BYMAX_BAD_REQUEST}.
+ *
+ * @param status - The HTTP status code of the response.
+ * @returns The catalogued code, or the client/internal fallback for any status
+ *   without a dedicated row.
+ */
+declare function codeForStatus(status: number): string;
+
+export { BYMAX_BAD_GATEWAY, BYMAX_BAD_REQUEST, BYMAX_CLIENT_ERROR, BYMAX_CONFLICT, BYMAX_CORE_OPTIONS, BYMAX_CORRELATION_PROVIDER, BYMAX_FORBIDDEN, BYMAX_GATEWAY_TIMEOUT, BYMAX_HEALTH_INDICATORS, BYMAX_INTERNAL_ERROR, BYMAX_METRICS_REGISTRY, BYMAX_NOT_FOUND, BYMAX_NOT_IMPLEMENTED, BYMAX_PAYLOAD_TOO_LARGE, BYMAX_SERVICE_UNAVAILABLE, BYMAX_TIMING_SINK, BYMAX_TOO_MANY_REQUESTS, BYMAX_UNAUTHORIZED, BYMAX_UNPROCESSABLE_ENTITY, BYMAX_UNSUPPORTED_MEDIA_TYPE, BYMAX_VALIDATION_FAILED, type BuildErrorEnvelopeInput, BymaxCoreModule, type BymaxCoreModuleOptions, BymaxExceptionFilter, type EnvelopeOptions, type ErrorDetails, type ErrorEnvelope, type FilterErrorContext, type HealthOptions, type ICorrelationIdProvider, type ITimingSink, type MetricsOptions, type RequestTimingSample, type ResolvedCoreOptions, TimingInterceptor, type TimingOptions, buildErrorEnvelope, codeForStatus };