@zudojs/errors 0.1.1 → 1.0.0

package/dist/infrastructure/service/externalServiceError.base.js

@@ -61,20 +61,17 @@ export function createExternalServiceError(service, message = "An external servi
 export function isExternalServiceError(value) {
     return value instanceof ExternalServiceError;
 }
-/** Maps a remote response status into an appropriate local HTTP status. */
-function mapResponseStatus(responseStatus) {
-    if (responseStatus === undefined) {
-        return 502;
-    }
-    if (responseStatus >= 500) {
-        return 502;
-    }
+/**
+ * Maps a remote response status into an appropriate local HTTP status.
+ *
+ * An upstream failure is our problem, not our caller's: every upstream status
+ * maps to 502 Bad Gateway except 429, which is passed through so that callers
+ * can back off. Pass an explicit `statusCode` option to override.
+ */
+export function mapResponseStatus(responseStatus) {
     if (responseStatus === 429) {
         return 429;
     }
-    if (responseStatus >= 400) {
-        return responseStatus;
-    }
     return 502;
 }
 //# sourceMappingURL=externalServiceError.base.js.map

package/dist/infrastructure/service/externalServiceError.factory.d.ts

@@ -5,5 +5,7 @@ import { ExternalServiceError } from "./externalServiceError.base.js";
 /** Creates an external service timeout error. */
 export declare function externalServiceTimeoutError(service: string, operation?: string): ExternalServiceError;
 /** Creates an external service unavailable error. */
-export declare function externalServiceUnavailable(service: string, operation?: string): ExternalServiceError;
+export declare function externalServiceUnavailableError(service: string, operation?: string): ExternalServiceError;
+/** @deprecated Use `externalServiceUnavailableError`. */
+export declare const externalServiceUnavailable: typeof externalServiceUnavailableError;
 //# sourceMappingURL=externalServiceError.factory.d.ts.map

package/dist/infrastructure/service/externalServiceError.factory.js

@@ -18,7 +18,7 @@ export function externalServiceTimeoutError(service, operation) {
     });
 }
 /** Creates an external service unavailable error. */
-export function externalServiceUnavailable(service, operation) {
+export function externalServiceUnavailableError(service, operation) {
     return new ExternalServiceError(`${service} is currently unavailable.`, {
         service,
         operation,
@@ -29,4 +29,6 @@ export function externalServiceUnavailable(service, operation) {
         expose: false,
     });
 }
+/** @deprecated Use `externalServiceUnavailableError`. */
+export const externalServiceUnavailable = externalServiceUnavailableError;
 //# sourceMappingURL=externalServiceError.factory.js.map

package/dist/infrastructure/storage/databaseError.factory.js

@@ -31,7 +31,7 @@ export function databaseTransactionError(message = "The database transaction fai
 export function databaseMigrationError(message = "The database migration failed.", options = {}) {
     return new DatabaseError(message, {
         ...options,
-        code: ErrorCode.DATABASE,
+        code: ErrorCode.DATABASE_MIGRATION,
         operation: DatabaseOperation.MIGRATION,
     });
 }

package/dist/infrastructure/storage/storageError.factory.js

@@ -2,7 +2,7 @@
  * Storage error factory functions.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
-import { StorageError, StorageOperation, } from "./storageError.base.js";
+import { StorageError, StorageOperation } from "./storageError.base.js";
 /** Creates a storage read error. */
 export function storageReadError(resource, provider, cause) {
     return new StorageError(`Failed to read "${resource}".`, {
@@ -56,7 +56,7 @@ export function storageDeleteError(resource, provider, cause) {
 /** Creates a storage not found error. */
 export function storageNotFoundError(resource, provider) {
     return new StorageError(`Resource "${resource}" was not found.`, {
-        code: ErrorCode.NOT_FOUND,
+        code: ErrorCode.STORAGE_NOT_FOUND,
         operation: StorageOperation.READ,
         provider,
         resource,

package/dist/system/cryptoError.factory.js

@@ -20,8 +20,11 @@ export function cryptoCipherError(message = "Cryptographic encryption or decrypt
     });
 }
 /** Creates a cryptographic signature error. */
-export function cryptoSignatureError(message = "Cryptographic signature verification failed.", operation = CryptoOperation.VERIFY_SIGNATURE, algorithm) {
-    return new CryptoError(message, {
+export function cryptoSignatureError(message, operation = CryptoOperation.VERIFY_SIGNATURE, algorithm) {
+    const defaultMessage = operation === CryptoOperation.SIGN
+        ? "Cryptographic signing failed."
+        : "Cryptographic signature verification failed.";
+    return new CryptoError(message ?? defaultMessage, {
         code: ErrorCode.CRYPTO_SIGNATURE,
         operation,
         algorithm,

package/dist/system/runtimeError.base.js

@@ -11,7 +11,7 @@ export class RuntimeError extends BaseError {
     constructor(message, options = {}) {
         super(message, {
             ...options,
-            code: options.code ?? ErrorCode.SYSTEM_ERROR,
+            code: options.code ?? ErrorCode.RUNTIME,
             category: options.category ?? ErrorCategory.RUNTIME,
             severity: options.severity ?? ErrorSeverity.ERROR,
             statusCode: options.statusCode ?? 500,

package/dist/utils/errorHandler.core.d.ts

@@ -1,30 +1,64 @@
 /**
  * Centralized error normalization, serialization, and reporting service.
  */
-import { BaseError } from "../base/core/baseError.core.js";
-import type { ErrorHandlerOptions, ErrorHandlerResult, ErrorHandlerContext, NormalizedError } from "./errorHandler.types.js";
-export type { ErrorHandlerOptions, ErrorHandlerResult, ErrorHandlerContext, ErrorReporter, NormalizedError, } from "./errorHandler.types.js";
+import type { BaseError } from "../base/core/baseError.core.js";
+import type { ErrorHandlerOptions, ErrorHandlerResult, ErrorHandlerContext, NormalizedError, PublicErrorHandlerResult } from "./errorHandler.types.js";
+export type { ErrorHandlerOptions, ErrorHandlerResult, ErrorHandlerContext, ErrorReporter, ErrorReporterFailureHandler, NormalizedError, PublicErrorHandlerResult, } from "./errorHandler.types.js";
 export { createErrorHandler, normalizeError, isHandledError, } from "./errorHandler.factory.js";
 /** Centralized error normalization, serialization, and reporting service. */
 export declare class ErrorHandler {
     private readonly reporter?;
+    private readonly onReporterError?;
     private readonly defaultStatusCode;
     private readonly defaultMessage;
     private readonly includeStack;
+    private readonly publicMetadataKeys;
+    private readonly sensitiveKeyPattern;
     constructor(options?: ErrorHandlerOptions);
     /** Converts an unknown thrown value into a BaseError. */
     normalize(value: unknown): NormalizedError;
-    /** Handles and normalizes an unknown error. */
+    /**
+     * Handles and normalizes an unknown error.
+     *
+     * The reporter is isolated: if it throws or rejects, the failure is passed
+     * to `onReporterError` (or swallowed) and the original error's result is
+     * still returned.
+     */
     handle(value: unknown, context?: ErrorHandlerContext): Promise<ErrorHandlerResult>;
-    /** Converts a BaseError into a safe response object. */
+    /** Handles an unknown error and returns the client-safe representation. */
+    handlePublic(value: unknown, context?: ErrorHandlerContext): Promise<PublicErrorHandlerResult>;
+    /**
+     * Converts a BaseError into the internal result object.
+     *
+     * Metadata is redacted recursively; the stack is never included.
+     */
     toResult(error: BaseError, context?: ErrorHandlerContext): ErrorHandlerResult;
+    /**
+     * Converts a BaseError into a client-safe result.
+     *
+     * Only `code`, `message`, `statusCode`, request/correlation ids and
+     * allow-listed metadata (`details`) are included. Internal classification
+     * fields and non-exposed metadata are never revealed.
+     */
+    toPublicResult(error: BaseError, context?: ErrorHandlerContext): PublicErrorHandlerResult;
     /** Reports an error without producing a response. */
     report(value: unknown, context?: ErrorHandlerContext): Promise<BaseError>;
     /** Determines whether an error should expose its message to clients. */
     shouldExpose(error: BaseError): boolean;
-    /** Returns a safe serialized error representation. */
+    /**
+     * Returns a safe serialized error representation (never includes a stack).
+     *
+     * Equivalent to `toPublicResult`; kept for backwards compatibility.
+     */
     serialize(error: BaseError, context?: ErrorHandlerContext): Record<string, unknown>;
-    /** Removes obviously sensitive fields from metadata before serialization. */
-    private sanitizeMetadata;
+    /**
+     * Returns the full internal representation for logging, including the
+     * (redacted) cause chain and, when `includeStack` is enabled, stack traces.
+     */
+    toLogObject(error: BaseError, context?: ErrorHandlerContext): Record<string, unknown>;
+    /** Invokes the reporter without letting its failure escape. */
+    private reportSafely;
+    /** Removes obviously sensitive fields from metadata (recursively). */
+    private redact;
 }
 //# sourceMappingURL=errorHandler.core.d.ts.map

package/dist/utils/errorHandler.core.js

@@ -1,67 +1,70 @@
 /**
  * Centralized error normalization, serialization, and reporting service.
  */
-import { BaseError } from "../base/core/baseError.core.js";
-import { ErrorCategory } from "../base/types/errorCategory.type.js";
-import { ErrorCode } from "../base/types/errorCode.type.js";
-import { ErrorSeverity } from "../base/types/errorSeverity.type.js";
+import { pickErrorMetadata, redactErrorMetadata, serializeErrorMetadata, } from "../base/core/errorMetadata.core.js";
+import { isBaseError, normalizeUnknownToBaseError, } from "../base/utils/baseError.utils.js";
+import { ErrorSerializer } from "./errorSerializer.core.js";
 export { createErrorHandler, normalizeError, isHandledError, } from "./errorHandler.factory.js";
 /** Centralized error normalization, serialization, and reporting service. */
 export class ErrorHandler {
     reporter;
+    onReporterError;
     defaultStatusCode;
     defaultMessage;
     includeStack;
+    publicMetadataKeys;
+    sensitiveKeyPattern;
     constructor(options = {}) {
         this.reporter = options.reporter;
+        this.onReporterError = options.onReporterError;
         this.defaultStatusCode = options.defaultStatusCode ?? 500;
         this.defaultMessage =
             options.defaultMessage ?? "An unexpected error occurred.";
         this.includeStack = options.includeStack ?? false;
+        this.publicMetadataKeys = options.publicMetadataKeys;
+        this.sensitiveKeyPattern = options.sensitiveKeyPattern;
     }
     /** Converts an unknown thrown value into a BaseError. */
     normalize(value) {
-        if (value instanceof BaseError) {
+        if (isBaseError(value)) {
             return { error: value, original: value };
         }
-        if (value instanceof Error) {
-            const error = new BaseError(value.message || this.defaultMessage, {
-                code: ErrorCode.INTERNAL_ERROR,
-                category: ErrorCategory.SYSTEM,
-                severity: ErrorSeverity.ERROR,
-                statusCode: this.defaultStatusCode,
-                expose: false,
-                isOperational: false,
-                cause: value,
-            });
-            return { error, original: value };
-        }
-        const message = typeof value === "string" ? value : this.defaultMessage;
-        const error = new BaseError(message, {
-            code: ErrorCode.INTERNAL_ERROR,
-            category: ErrorCategory.SYSTEM,
-            severity: ErrorSeverity.ERROR,
+        const error = normalizeUnknownToBaseError(value, {
             statusCode: this.defaultStatusCode,
-            expose: false,
-            isOperational: false,
-            metadata: { originalType: typeof value },
+            ...(value instanceof Error || typeof value === "string"
+                ? {}
+                : { message: this.defaultMessage }),
         });
         return { error, original: value };
     }
-    /** Handles and normalizes an unknown error. */
+    /**
+     * Handles and normalizes an unknown error.
+     *
+     * The reporter is isolated: if it throws or rejects, the failure is passed
+     * to `onReporterError` (or swallowed) and the original error's result is
+     * still returned.
+     */
     async handle(value, context) {
         const { error } = this.normalize(value);
-        if (this.reporter) {
-            await this.reporter(error, context);
-        }
+        await this.reportSafely(error, context);
         return this.toResult(error, context);
     }
-    /** Converts a BaseError into a safe response object. */
+    /** Handles an unknown error and returns the client-safe representation. */
+    async handlePublic(value, context) {
+        const { error } = this.normalize(value);
+        await this.reportSafely(error, context);
+        return this.toPublicResult(error, context);
+    }
+    /**
+     * Converts a BaseError into the internal result object.
+     *
+     * Metadata is redacted recursively; the stack is never included.
+     */
     toResult(error, context) {
-        const metadata = {
-            ...(error.toJSON().metadata ?? {}),
+        const metadata = this.redact({
+            ...serializeErrorMetadata(error.metadata),
             ...(context?.metadata ?? {}),
-        };
+        });
         return {
             code: error.code,
             message: error.expose ? error.message : this.defaultMessage,
@@ -74,51 +77,101 @@ export class ErrorHandler {
             ...(context?.correlationId
                 ? { correlationId: context.correlationId }
                 : {}),
-            ...(Object.keys(metadata).length > 0
-                ? { metadata: this.sanitizeMetadata(metadata) }
+            ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+        };
+    }
+    /**
+     * Converts a BaseError into a client-safe result.
+     *
+     * Only `code`, `message`, `statusCode`, request/correlation ids and
+     * allow-listed metadata (`details`) are included. Internal classification
+     * fields and non-exposed metadata are never revealed.
+     */
+    toPublicResult(error, context) {
+        let details;
+        if (this.publicMetadataKeys !== undefined) {
+            details = this.redact(pickErrorMetadata(error.metadata, this.publicMetadataKeys));
+        }
+        else if (error.expose) {
+            details = this.redact(error.metadata);
+        }
+        return {
+            code: error.code,
+            message: error.expose ? error.message : this.defaultMessage,
+            statusCode: error.statusCode,
+            ...(context?.requestId ? { requestId: context.requestId } : {}),
+            ...(context?.correlationId
+                ? { correlationId: context.correlationId }
+                : {}),
+            ...(details !== undefined && Object.keys(details).length > 0
+                ? { details }
                 : {}),
         };
     }
     /** Reports an error without producing a response. */
     async report(value, context) {
         const { error } = this.normalize(value);
-        if (this.reporter) {
-            await this.reporter(error, context);
-        }
+        await this.reportSafely(error, context);
         return error;
     }
     /** Determines whether an error should expose its message to clients. */
     shouldExpose(error) {
         return error.expose;
     }
-    /** Returns a safe serialized error representation. */
+    /**
+     * Returns a safe serialized error representation (never includes a stack).
+     *
+     * Equivalent to `toPublicResult`; kept for backwards compatibility.
+     */
     serialize(error, context) {
-        const result = this.toResult(error, context);
-        if (this.includeStack && error.expose === false) {
-            return { ...result, stack: error.stack };
-        }
-        return result;
+        return this.toPublicResult(error, context);
     }
-    /** Removes obviously sensitive fields from metadata before serialization. */
-    sanitizeMetadata(metadata) {
-        const sensitiveKeys = new Set([
-            "password",
-            "passcode",
-            "token",
-            "accessToken",
-            "refreshToken",
-            "authorization",
-            "cookie",
-            "secret",
-            "privateKey",
-            "apiKey",
-            "credential",
-        ]);
-        const sanitized = {};
-        for (const [key, value] of Object.entries(metadata)) {
-            sanitized[key] = sensitiveKeys.has(key) ? "[REDACTED]" : value;
+    /**
+     * Returns the full internal representation for logging, including the
+     * (redacted) cause chain and, when `includeStack` is enabled, stack traces.
+     */
+    toLogObject(error, context) {
+        const serialized = new ErrorSerializer({
+            includeStack: this.includeStack,
+            includeCause: true,
+            includeMetadata: true,
+            redactSensitiveData: true,
+            sensitiveKeyPattern: this.sensitiveKeyPattern,
+        }).serialize(error);
+        return {
+            ...serialized,
+            ...(context?.requestId ? { requestId: context.requestId } : {}),
+            ...(context?.correlationId
+                ? { correlationId: context.correlationId }
+                : {}),
+            ...(context?.metadata
+                ? { context: this.redact(context.metadata) }
+                : {}),
+        };
+    }
+    /** Invokes the reporter without letting its failure escape. */
+    async reportSafely(error, context) {
+        if (!this.reporter)
+            return;
+        try {
+            await this.reporter(error, context);
+        }
+        catch (reporterError) {
+            if (this.onReporterError) {
+                try {
+                    this.onReporterError(reporterError, error, context);
+                }
+                catch {
+                    // A failing failure-handler must never break error handling.
+                }
+            }
         }
-        return sanitized;
+    }
+    /** Removes obviously sensitive fields from metadata (recursively). */
+    redact(metadata) {
+        return redactErrorMetadata(metadata, {
+            sensitiveKeyPattern: this.sensitiveKeyPattern,
+        });
     }
 }
 //# sourceMappingURL=errorHandler.core.js.map

package/dist/utils/errorHandler.factory.d.ts

@@ -1,7 +1,7 @@
 /**
  * Error handler factory functions.
  */
-import { BaseError } from "../base/core/baseError.core.js";
+import type { BaseError } from "../base/core/baseError.core.js";
 import { ErrorHandler } from "./errorHandler.core.js";
 import type { ErrorHandlerOptions } from "./errorHandler.types.js";
 /** Creates a default error handler. */

package/dist/utils/errorHandler.factory.js

@@ -1,7 +1,7 @@
 /**
  * Error handler factory functions.
  */
-import { BaseError } from "../base/core/baseError.core.js";
+import { isBaseError } from "../base/utils/baseError.utils.js";
 import { ErrorHandler } from "./errorHandler.core.js";
 /** Creates a default error handler. */
 export function createErrorHandler(options = {}) {
@@ -13,6 +13,6 @@ export function normalizeError(value) {
 }
 /** Determines whether an unknown value is a supported BaseError. */
 export function isHandledError(value) {
-    return value instanceof BaseError;
+    return isBaseError(value);
 }
 //# sourceMappingURL=errorHandler.factory.js.map

package/dist/utils/errorHandler.types.d.ts

@@ -18,7 +18,13 @@ export interface NormalizedError {
     readonly error: BaseError;
     readonly original: unknown;
 }
-/** Structured result returned by the error handler. */
+/**
+ * Structured result returned by the error handler.
+ *
+ * This is the INTERNAL representation (classification fields and redacted
+ * metadata included); use `ErrorHandler.toPublicResult` / `PublicErrorHandlerResult`
+ * for anything returned to an untrusted client.
+ */
 export interface ErrorHandlerResult {
     readonly code: string;
     readonly message: string;
@@ -31,13 +37,43 @@ export interface ErrorHandlerResult {
     readonly correlationId?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
+/** Client-safe result returned by `ErrorHandler.toPublicResult`. */
+export interface PublicErrorHandlerResult {
+    readonly code: string;
+    readonly message: string;
+    readonly statusCode: number;
+    readonly requestId?: string;
+    readonly correlationId?: string;
+    /** Allow-listed, redacted metadata (see `ErrorHandlerOptions.publicMetadataKeys`). */
+    readonly details?: Readonly<Record<string, unknown>>;
+}
 /** Callback used to report errors to an external logger or monitoring system. */
 export type ErrorReporter = (error: BaseError, context?: ErrorHandlerContext) => void | Promise<void>;
+/** Callback invoked when the reporter itself fails. */
+export type ErrorReporterFailureHandler = (reporterError: unknown, originalError: BaseError, context?: ErrorHandlerContext) => void;
 /** Options for constructing an ErrorHandler. */
 export interface ErrorHandlerOptions {
     readonly reporter?: ErrorReporter;
+    /**
+     * Invoked when `reporter` throws or rejects. Reporter failures never
+     * propagate out of `handle`/`report`; when this hook is absent they are
+     * swallowed.
+     */
+    readonly onReporterError?: ErrorReporterFailureHandler;
     readonly defaultStatusCode?: number;
     readonly defaultMessage?: string;
+    /**
+     * Include the stack trace in `toLogObject` output. Stacks are never
+     * included in `toResult`, `toPublicResult` or `serialize`.
+     */
     readonly includeStack?: boolean;
+    /**
+     * Metadata keys copied into `PublicErrorHandlerResult.details`. When omitted,
+     * exposed errors contribute their (redacted) metadata and non-exposed errors
+     * contribute nothing.
+     */
+    readonly publicMetadataKeys?: readonly string[];
+    /** Pattern used to detect sensitive metadata keys. */
+    readonly sensitiveKeyPattern?: RegExp;
 }
 //# sourceMappingURL=errorHandler.types.d.ts.map

package/dist/utils/errorMapper.core.d.ts

@@ -3,5 +3,5 @@
  */
 export type { ErrorMapperContext, ErrorMapping, ErrorMapperPredicate, ErrorMapper, ErrorMappingRule, } from "./errorMapper.types.js";
 export { ErrorMapperRegistry, createErrorMapperRegistry, } from "./errorMapper.registry.js";
-export { mapNativeError, mapError, mapErrorType, createErrorMappingRule, } from "./errorMapper.mappers.js";
+export { mapNativeError, mapError, mapErrorType, createErrorMappingRule, applyErrorMapping, type ErrorConstructor, } from "./errorMapper.mappers.js";
 //# sourceMappingURL=errorMapper.core.d.ts.map

package/dist/utils/errorMapper.core.js

@@ -2,5 +2,5 @@
  * Error mapper — re-exports from focused files.
  */
 export { ErrorMapperRegistry, createErrorMapperRegistry, } from "./errorMapper.registry.js";
-export { mapNativeError, mapError, mapErrorType, createErrorMappingRule, } from "./errorMapper.mappers.js";
+export { mapNativeError, mapError, mapErrorType, createErrorMappingRule, applyErrorMapping, } from "./errorMapper.mappers.js";
 //# sourceMappingURL=errorMapper.core.js.map

package/dist/utils/errorMapper.mappers.d.ts

@@ -2,14 +2,35 @@
  * Error mapping functions — native error mapping, registry-based mapping, rule creation.
  */
 import { BaseError } from "../base/core/baseError.core.js";
-import type { ErrorMapperContext, ErrorMapper, ErrorMapperPredicate, ErrorMappingRule } from "./errorMapper.types.js";
+import type { ErrorMapperContext, ErrorMapper, ErrorMapperPredicate, ErrorMapping, ErrorMappingRule } from "./errorMapper.types.js";
 import type { ErrorMapperRegistry } from "./errorMapper.registry.js";
-/** Maps common native JavaScript errors. */
+/**
+ * Maps common native JavaScript errors.
+ *
+ * Native `TypeError`/`RangeError`/`SyntaxError` are overwhelmingly programmer
+ * bugs rather than client input problems, so they are classified as
+ * non-operational internal errors (500, not exposed). Register an explicit
+ * mapping rule to treat a specific error type as client input.
+ */
 export declare function mapNativeError(error: unknown): BaseError | undefined;
 /** Maps an error using a registry and falls back to native error mapping. */
 export declare function mapError(error: unknown, registry?: ErrorMapperRegistry, context?: ErrorMapperContext): BaseError;
-/** Creates a mapping rule for a specific error constructor. */
-export declare function mapErrorType<T extends Error>(name: string, errorType: new (...args: unknown[]) => T, mapper: (error: T, context?: ErrorMapperContext) => BaseError, priority?: number): ErrorMappingRule;
-/** Creates a mapping rule based on a predicate. */
-export declare function createErrorMappingRule(name: string, predicate: ErrorMapperPredicate, mapper: ErrorMapper, priority?: number): ErrorMappingRule;
+/** Any constructor whose instances are `T` (parameters are not constrained). */
+export type ErrorConstructor<T extends Error> = abstract new (...args: any[]) => T;
+/**
+ * Creates a mapping rule for a specific error constructor.
+ *
+ * `mapper` may be a function producing a `BaseError`, or a declarative
+ * `ErrorMapping` describing the resulting error.
+ */
+export declare function mapErrorType<T extends Error>(name: string, errorType: ErrorConstructor<T>, mapper: ((error: T, context?: ErrorMapperContext) => BaseError) | ErrorMapping, priority?: number): ErrorMappingRule;
+/**
+ * Creates a mapping rule based on a predicate.
+ *
+ * `mapper` may be a function producing a `BaseError`, or a declarative
+ * `ErrorMapping` describing the resulting error.
+ */
+export declare function createErrorMappingRule(name: string, predicate: ErrorMapperPredicate, mapper: ErrorMapper | ErrorMapping, priority?: number): ErrorMappingRule;
+/** Builds a BaseError from a declarative `ErrorMapping`. */
+export declare function applyErrorMapping(error: unknown, mapping: ErrorMapping, context?: ErrorMapperContext): BaseError;
 //# sourceMappingURL=errorMapper.mappers.d.ts.map