@emoyly/problem 8.0.5 → 8.0.6

package/esm/middleware/base.d.ts

@@ -6,25 +6,25 @@ import type { MiddlewareOptions, PartialMiddlewareOptions, ProblemListener } fro
  */
 export declare abstract class MiddlewareBase {
     readonly options: MiddlewareOptions;
-    abstract name: string;
+    abstract readonly name: string;
     /**
      * When nothing is returned from the parsers, just throw in a default "fallback" Problem object, so that a Problem is still actually returned/emitted
      */
-    readonly enableFallback = true;
+    readonly enableFallback: boolean;
     constructor(defaultOptions: MiddlewareOptions, options?: PartialMiddlewareOptions);
     /**
      * Parse input using parsers
      */
-    protected parse: (input: unknown) => Problem[];
-    protected fallback: ProblemOpts;
-    protected problemListeners: ProblemListener[];
+    protected readonly parse: (input: unknown) => Problem[];
+    protected readonly fallback: ProblemOpts;
+    protected readonly problemListeners: ProblemListener[];
     protected emit: (list: Problem[]) => void;
     /**
      * Listen to problems
      */
-    onProblem: (listener: ProblemListener) => void;
+    readonly onProblem: (listener: ProblemListener) => void;
     /**
      * Un-listen to problems
      */
-    offProblem: (listener: ProblemListener) => void;
+    readonly offProblem: (listener: ProblemListener) => void;
 }

package/esm/middleware/express.d.ts

@@ -2,18 +2,18 @@ import type { NextFunction, Request, Response } from 'express';
 import type { PartialMiddlewareOptions } from '../typings/middleware.js';
 import { MiddlewareBase } from './base.js';
 export declare class ExpressMiddleware extends MiddlewareBase {
-    name: string;
-    middleware: (error: unknown, req: Request, res: Response, next: NextFunction) => void;
+    readonly name = "express";
+    private middleware;
     /**
      * This function applies the middleware to your Express application. Put this at the very end of your middleware/routes.
      * If you want to also handle 404 errors, check out the notFound middleware function.
      * @example app.use(middleware.use())
      */
-    use: () => (error: unknown, req: Request, res: Response, next: NextFunction) => void;
+    readonly use: () => (error: unknown, req: Request, res: Response, next: NextFunction) => void;
     constructor(options?: PartialMiddlewareOptions);
     /**
      * Put this right before the middleware.use() to catch all 404 errors and respond with a Problem instead of the default Express response
      * @example app.use(middleware.notFound)
      */
-    notFound: (req: Request, res: Response, next: NextFunction) => void;
+    readonly notFound: (req: Request, res: Response, next: NextFunction) => void;
 }

package/esm/problem.d.ts

@@ -6,7 +6,7 @@ export declare class Problem extends Error implements IProblem {
     detail: string | undefined;
     instance: string | undefined;
     errorObject?: unknown;
-    readonly __problemVersion = "8.0.5";
+    readonly __problemVersion = "8.0.6";
     data: unknown;
     source?: string;
     constructor(opts: ProblemOpts);