nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/types/Cli.d.ts

@@ -0,0 +1,177 @@
+import fs from "node:fs";
+import { program, Command as CommanderCommand, ParseOptions, HelpContext, ExecutableCommandOptions } from "commander";
+import { SpawnSyncReturns, SpawnSyncOptionsWithStringEncoding, SpawnOptions } from "node:child_process";
+import semver from "semver";
+import Table, { TableConstructorOptions } from "cli-table3";
+import { type ColorFn, type Clc } from "./colors.js";
+import Service, { DefaultOptionsService } from "./Service.js";
+import Container from "./Container.js";
+import FileClass from "./FileClass.js";
+import Event from "./Event.js";
+import Command from "./command/Command.js";
+import { DebugType, EnvironmentType } from "./types/globals.js";
+import Syslog from "./syslog/Syslog.js";
+import Kernel from "./kernel/Kernel.js";
+interface CliDefaultOptions extends DefaultOptionsService {
+    processName?: string;
+    autostart?: boolean;
+    asciify?: boolean;
+    clear?: boolean;
+    color?: ColorFn;
+    prompt?: string;
+    commander?: boolean;
+    signals?: boolean;
+    autoLogger?: boolean;
+    resize?: boolean;
+    version?: string;
+    warning?: boolean;
+    pid?: boolean;
+    promiseRejection?: boolean;
+    font?: string;
+    environment?: EnvironmentType;
+}
+export type PackageManagerName = "npm" | "yarn" | "pnpm" | "bun";
+declare class Cli extends Service {
+    #private;
+    options: CliDefaultOptions;
+    debug: DebugType;
+    environment: EnvironmentType;
+    commander: typeof program | null;
+    protected commands: Record<string, Command>;
+    pid: number | null;
+    interactive: boolean;
+    unhandledRejections: Map<Promise<unknown>, string>;
+    response: Record<string, any>;
+    timers: Record<string, string>;
+    version: string;
+    clc: Clc;
+    blankLine: () => void;
+    columns: number;
+    rows: number;
+    /**
+     * Vrai dès le 1ᵉʳ signal d'arrêt reçu. Empêche un 2ᵉ signal de relancer un
+     * `terminate()` gracieux complet (re-fire `onTerminate`, double SHUTDOWN des
+     * serveurs). Le 2ᵉ signal force la sortie immédiate — cf {@link handleSignals}.
+     */
+    protected shuttingDown: boolean;
+    /** Numéros POSIX → code de sortie forcé `128 + signum` au 2ᵉ signal. */
+    protected static readonly SIGNUM: Record<string, number>;
+    constructor(name?: string);
+    constructor(name: string, options: CliDefaultOptions);
+    constructor(name: string, container: Container | null | undefined, options: CliDefaultOptions);
+    constructor(name: string, container: Container | null | undefined, notificationsCenter: Event | false | undefined, options: CliDefaultOptions);
+    protected handleSignals(): void;
+    /**
+     * Mémorise DE QUOI retirer un listener de `process`.
+     *
+     * Prend le retrait déjà fermé sur la référence du handler, plutôt que le
+     * couple (événement, handler) : c'est ce qui permet de garder chaque listener
+     * typé exactement (`NodeJS.Signals`, `Error`, `Promise<unknown>`) sans un seul
+     * cast au moment de le retirer.
+     *
+     * @param off - retire le listener correspondant, et rien d'autre.
+     * @param signal - `true` s'il s'agit d'un gestionnaire de SIGNAL. Ce n'est
+     *   pas une étiquette de confort : le mode cluster doit reprendre la main sur
+     *   les signaux SANS toucher aux autres listeners de cette instance
+     *   (`warning`, `unhandledRejection`), que le master garde. Cf
+     *   {@link releaseSignalListeners}.
+     */
+    protected trackProcessListener(off: () => void, signal?: boolean): void;
+    /**
+     * Retire tous les listeners que cette instance a posés sur `process`.
+     *
+     * Sans effet utile en production — le process meurt avec son `Cli` — mais
+     * indispensable dès qu'un même process en instancie plusieurs (tests, outils
+     * qui enchaînent des commandes) : sinon chaque instance ajoute sept listeners
+     * que personne ne peut plus retirer.
+     *
+     * Idempotent : un second appel ne retire rien et rend `0`.
+     *
+     * @returns le nombre de listeners effectivement retirés.
+     */
+    releaseProcessListeners(): number;
+    /**
+     * Retire les gestionnaires de SIGNAUX de cette instance — et rien d'autre.
+     *
+     * 🔴 Il existe pour remplacer un `process.removeAllListeners(sig)`, qui
+     * arrachait AUSSI les gestionnaires qu'un module tiers avait posés sur
+     * `SIGTERM` pour son propre arrêt propre. Ce module ne recevait plus rien, et
+     * rien ne le lui disait : son code était juste, ses tests passaient, et son
+     * nettoyage cessait simplement de s'exécuter le jour où l'application passait
+     * en cluster — au moment le plus coûteux, l'arrêt.
+     *
+     * On ne retire donc que ce qu'on a posé soi-même. Les autres listeners de
+     * cette instance (`warning`, `unhandledRejection`, `uncaughtException`)
+     * restent : le master cluster en a besoin autant que n'importe quel process.
+     *
+     * @returns le nombre de gestionnaires de signaux retirés.
+     */
+    releaseSignalListeners(): number;
+    private handleWarnings;
+    start(): Promise<Cli | Kernel>;
+    idle(): {
+        resolve: null;
+        promise: Promise<unknown>;
+        reject: null;
+    };
+    checkVersion(version?: string | semver.SemVer | null | undefined): string;
+    showAsciify(name?: string | null): Promise<this>;
+    showBanner(): string | null;
+    listenRejection(): void;
+    setPid(): number;
+    setProcessTitle(name?: string): string;
+    logEnv(): string;
+    initCommander(): typeof program | null;
+    initUi(): void;
+    getFonts(): Promise<void>;
+    asciify(txt: string, options?: object, callback?: (error: Error, data: string) => void): Promise<string>;
+    parse(argv?: string[], options?: ParseOptions): CommanderCommand;
+    parseAsync(argv?: string[], options?: ParseOptions): Promise<CommanderCommand>;
+    clearCommand(): void;
+    runCommand(cmd: string, args?: any[]): CommanderCommand;
+    runCommandAsync(cmd: string, args?: any[]): Promise<CommanderCommand>;
+    setCommandOption(flags: string, description?: string, defaultValue?: string | boolean | string[] | undefined): CommanderCommand;
+    setCommandVersion(version: string): CommanderCommand;
+    setCommand(nameAndArgs: string, description: string, options?: ExecutableCommandOptions | undefined): CommanderCommand;
+    addCommand(cliCommand: new (cli: this) => Command): Command;
+    hasCommand(name: string): boolean;
+    getCommand(name: string): Command | null;
+    showHelp(quit: boolean, context: HelpContext | undefined): void | never;
+    displayTable(datas: any[], options: TableConstructorOptions, syslog?: Syslog | null): Table.Table;
+    static niceBytes(x: string | number): string;
+    /**
+     * Temps relatif lisible ("a few seconds ago", "24 years ago") — natif via
+     * `Intl.RelativeTimeFormat` (remplace `moment().fromNow()`, dep supprimée).
+     *
+     * @param date - instant de référence (Date, timestamp ms, ou string parsable).
+     * @param suffix - `true` = sans suffixe "ago"/"in" (parité `moment.fromNow(true)`).
+     */
+    static niceUptime(date: Date | number | string, suffix?: boolean | undefined): string;
+    /**
+     * Formate une date selon des tokens `moment`-like (`YYYY MM DD HH mm ss SSS`)
+     * en heure **locale** — natif (remplace `moment().format()`, dep supprimée).
+     *
+     * @param date - Date, timestamp ms, ou string parsable.
+     * @param format - patron (défaut `"YYYY-MM-DD HH:mm:ss"`).
+     */
+    static niceDate(date: Date | number | string, format?: string | undefined): string;
+    clear(): void;
+    reset(): void;
+    resize(): void;
+    createDirectory(myPath: fs.PathLike, mode?: fs.MakeDirectoryOptions | fs.Mode | null, force?: boolean): Promise<FileClass>;
+    existsSync(myPath: fs.PathLike): boolean;
+    exists(myPath: fs.PathLike, mode?: number | undefined, callback?: fs.NoParamCallback): void | boolean;
+    terminate(code?: number, quiet?: boolean): Promise<void | never>;
+    static quit(code: number): void;
+    startTimer(name: string): void;
+    stopTimer(name: string): void;
+    getCommandManager(manager: string): "npm" | "npm.cmd" | "pnpm" | "pnpm.cmd" | "yarn" | "yarn.cmd";
+    runPackageManager(argv: string[] | undefined, cwd: string | undefined, env: EnvironmentType, manager: string): Promise<number | Error>;
+    npm(argv?: string[], cwd?: string, env?: EnvironmentType): Promise<number | Error>;
+    yarn(argv?: string[], cwd?: string, env?: EnvironmentType): Promise<number | Error>;
+    pnpm(argv?: string[], cwd?: string, env?: EnvironmentType): Promise<number | Error>;
+    spawn(command: string, args: readonly string[] | undefined, options: SpawnOptions | undefined, close?: ((code: number) => void) | null): Promise<unknown>;
+    spawnSync(command: string, args: readonly string[], options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+}
+export default Cli;
+export { CliDefaultOptions };

package/dist/types/Container.d.ts

@@ -0,0 +1,221 @@
+import type { Message, Msgid, Pci, Severity } from "./syslog/Pdu.js";
+import Syslog from "./syslog/Syslog.js";
+import type { IContainer, IScope } from "./types/IContainer.js";
+export interface DynamicService {
+    [key: string]: unknown;
+}
+export interface DynamicParam {
+    [key: string]: unknown;
+}
+/**
+ * Bookkeeping des scopes ouverts : nom de scope → instances vivantes par id.
+ * `Map` (et plus un objet `delete`-é) : l'ajout/retrait a lieu à CHAQUE
+ * requête — le churn de shape d'un objet ordinaire dégrade les inline caches
+ * V8, la Map est conçue pour ce motif.
+ */
+export type Scopes = Map<string, Map<string, Scope>>;
+export type ProtoService = {
+    (): void;
+    [key: string]: any;
+};
+export type ProtoParameters = {
+    (): void;
+    [key: string]: any;
+};
+/**
+ * Dependency Injection container — registers services by name and exposes
+ * them to the rest of the framework.
+ *
+ * Services are stored on a prototype-backed object (`protoService`) so they
+ * are inherited by child scopes (see {@link Scope}). The container also
+ * carries an arbitrary parameter tree (`parameters`) used for configuration.
+ *
+ * Conventional usage:
+ * ```ts
+ * const c = new Container();
+ * c.set("logger", new LoggerService());
+ * c.setParameters("kernel.environment", "development");
+ * const logger = c.get<LoggerService>("logger");
+ * ```
+ *
+ * See `src/nodefony/docs/container.md` for the high-level rationale and the
+ * scope model used by the HTTP/WS request pipeline.
+ */
+declare class Container implements IContainer {
+    protoService: ProtoService;
+    protected services: DynamicService | null;
+    protoParameters: ProtoParameters;
+    protected parameters: DynamicParam | null;
+    id: string;
+    private scopes;
+    private setServices;
+    private setParametersBulk;
+    /**
+     * Emit a log entry through the registered `syslog` service. Falls back to
+     * `console.warn` when no syslog is set (early boot, isolated test).
+     *
+     * @param pci - log payload (string or structured PDU body)
+     * @param severity - syslog severity level
+     * @param msgid - message id; defaults to `"SERVICES CONTAINER"`
+     * @param msg - optional message detail
+     */
+    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): ReturnType<Syslog["log"]> | void;
+    /**
+     * Register a service under `name`. The service is stored both directly on
+     * the container and on its prototype, so child scopes can read it without
+     * an extra hop.
+     *
+     * @param name - service identifier (any non-empty string)
+     * @param object - the instance to register (no type constraint — services
+     * are not required to extend any base class)
+     * @throws Error if `name` is empty or the container has been cleaned
+     */
+    set<T>(name: string, object: T): void;
+    /**
+     * Resolve a service by name. Returns `null` if the service is unknown or
+     * the container has been cleaned — callers should narrow the result
+     * before use.
+     *
+     * @param name - service identifier
+     * @returns the service instance typed as `T`, or `null`
+     */
+    get<T = unknown>(name: string): T | null;
+    /**
+     * Unregister a service and cascade the removal into every child scope.
+     *
+     * @param name - service identifier
+     * @returns `true` when a service was actually removed, `false` otherwise
+     */
+    remove(name: string): boolean;
+    /** Whether a service is registered under `name`. */
+    has(name: string): boolean;
+    /** All service names currently registered on this container. */
+    keys(): string[];
+    /** All `[name, service]` pairs currently registered on this container. */
+    entries(): [string, unknown][];
+    /**
+     * Declare a scope. Scopes are short-lived containers (typically created
+     * per HTTP/WS request) that inherit services from this container but
+     * store their own per-request services and parameters. Must be called
+     * once before {@link enterScope} can produce instances.
+     *
+     * @param name - scope identifier (e.g. `"request"`)
+     * @returns the underlying scope bucket (rarely used by callers)
+     */
+    addScope(name: string): Map<string, Scope>;
+    /**
+     * Open a new instance of the named scope. The returned {@link Scope}
+     * inherits services from this container but tracks its own services and
+     * parameters in isolation.
+     *
+     * @param name - scope name previously declared via {@link addScope}
+     * @returns a fresh `Scope` instance with a unique `id`
+     * @throws Error when the scope has not been declared
+     */
+    enterScope(name: string): Scope;
+    /**
+     * Close a scope instance and release its services/parameters. Always
+     * called when the unit of work that opened the scope finishes (request
+     * end, WS close).
+     *
+     * @param scope - the scope instance returned by {@link enterScope}
+     */
+    leaveScope(scope: IScope): void;
+    /**
+     * Nombre d'instances VIVANTES du scope nommé — introspection bon marché
+     * (sondes de fuite, Studio, diagnostics) sans exposer la structure interne.
+     *
+     * @param name - scope identifier (e.g. `"request"`)
+     * @returns le nombre de scopes ouverts, `0` si le scope est inconnu
+     */
+    scopeCount(name: string): number;
+    /**
+     * Close every open instance of the named scope and forget it. After this
+     * call, {@link enterScope}(`name`) will throw until {@link addScope} is
+     * called again.
+     *
+     * @param name - scope identifier
+     */
+    removeScope(name: string): void;
+    private removeAllScopes;
+    /**
+     * Set a value in the parameter tree using a dotted path. Intermediate
+     * objects are created on demand (`a.b.c = 1` creates `a` and `b` if they
+     * are missing).
+     *
+     * @param name - dotted path (e.g. `"kernel.environment"`)
+     * @param ele - value to assign (must not be `undefined`)
+     * @returns the parameter subtree containing the assigned value, or `null`
+     * if the container has been cleaned
+     * @throws Error when `name` is not a string or `ele` is `undefined`
+     */
+    setParameters<T>(name: string, ele: T): DynamicParam | null;
+    /**
+     * Read a value (or subtree) from the parameter tree.
+     *
+     * @param name - dotted path (e.g. `"kernel.environment"`)
+     * @returns the value, the subtree, or `null` if absent
+     * @throws Error when `name` is empty
+     */
+    getParameters(name: string): DynamicParam | null;
+    /**
+     * Tear the container down: close every scope, drop services and
+     * parameters. After `clean()`, any `get`/`set`/`enterScope` call on this
+     * instance throws or returns `null`. Called by the kernel during
+     * graceful shutdown.
+     */
+    clean(): void;
+    /**
+     * Clean the container and rebuild fresh prototype chains, leaving it
+     * ready to register services again. Used by hot-reload paths in tests
+     * and dev mode; production code rarely calls this directly.
+     */
+    reset(): void;
+}
+/**
+ * Short-lived child container tied to a parent {@link Container}. Used by
+ * the HTTP/WS kernel to isolate per-request services (e.g. request-bound
+ * sessions, scoped resolvers) without polluting the global container.
+ *
+ * Services and parameters defined on a `Scope` shadow the parent's — reads
+ * fall back to the parent transparently when nothing is found locally.
+ */
+declare class Scope extends Container implements IScope {
+    name: string;
+    private parent;
+    constructor(name: string, parent: Container, parentProtoService: ProtoService, parentProtoParameters: ProtoParameters);
+    /**
+     * Register a per-request service — own property ONLY (shadowing). Depuis
+     * l'adoption des protos parents, l'écriture prototype de
+     * {@link Container.set} toucherait le proto PARTAGÉ du parent : un service
+     * per-request (controller, context) deviendrait visible de TOUTES les
+     * requêtes concurrentes. (L'ancien chemin écrivait sur un proto local mort
+     * — travail perdu à chaque set.)
+     */
+    set<T>(name: string, object: T): void;
+    /**
+     * Unregister a service registered ON THIS SCOPE (own property only). Les
+     * services hérités du parent ne sont jamais touchés — même raison que
+     * {@link Scope.set} : le proto est partagé depuis l'adoption.
+     */
+    remove(name: string): boolean;
+    /**
+     * Read a parameter from the scope, falling back to the parent container.
+     * When both sides hold plain objects, the result is a merged view (deep
+     * by default) so a scope can override a few keys without losing the rest.
+     *
+     * @param name - dotted path
+     * @param merge - when `true` (default), merge scope and parent objects;
+     * when `false`, scope value wins outright if present
+     * @param deep - deep vs. shallow merge (only when `merge` is `true`)
+     */
+    getParameters(name: string, merge?: boolean, deep?: boolean): DynamicParam | null;
+    /**
+     * Break the parent link and clean the scope. Called by
+     * {@link Container.leaveScope} when the unit of work that owns the scope
+     * finishes.
+     */
+    clean(): void;
+}
+export default Container;
+export { Scope };

package/dist/types/Error.d.ts

@@ -0,0 +1,162 @@
+declare global {
+    interface Error {
+        errno?: string | number;
+        bytesParsed?: number;
+        errors?: any;
+        parent?: Error;
+        actual?: any;
+        expected?: any;
+        operator?: any;
+        syscall?: any;
+        address?: any;
+        port?: any;
+        rawPacket?: any;
+        fields?: any;
+        code?: any;
+        index?: any;
+        value?: any;
+        table?: any;
+        constraint?: any;
+    }
+}
+/**
+ * Adapter d'erreurs d'une bibliothèque tierce (driver ORM, client externe…).
+ *
+ * Permet au core de **reconnaître** (`isError`) et **formater** (`errorToString`)
+ * une famille d'erreurs sans dépendre de la bibliothèque : le module tiers fournit
+ * l'implémentation et s'enregistre via {@link registerErrorAdapter}. Le core reste
+ * agnostique — il ne nomme aucun driver.
+ */
+export interface IErrorAdapter {
+    /** Vrai si l'erreur relève de la famille gérée par cet adapter. */
+    isError(e: Error): boolean;
+    /** Formate l'erreur en message lisible. */
+    errorToString(e: unknown): string;
+}
+/**
+ * Enregistre un adapter d'erreurs tiers sous une clé (ex. le nom du driver ORM
+ * `"mongoose"`). Inversion de dépendance : le module s'enregistre lui-même à son
+ * boot, le core ne connaît aucune bibliothèque. `null` retire l'adapter (teardown,
+ * tests).
+ *
+ * @param name - clé unique de l'adapter (nom du module/driver).
+ * @param adapter - implémentation `{ isError, errorToString }`, ou `null` pour retirer.
+ */
+export declare function registerErrorAdapter(name: string, adapter: IErrorAdapter | null): void;
+/**
+ * Erreur Nodefony — wrapper riche autour de `Error` natif qui ajoute :
+ * - Un `code` numérique (HTTP status ou code custom — pas un string).
+ * - Un `errorType` détecté automatiquement (TypeError, SystemError,
+ *   AssertionError, OrmError, ClientError, etc.).
+ * - Une sérialisation `toJSON()` filtrée qui exclut `context`, `resolver`,
+ *   `container`, `secure` (références circulaires).
+ * - Un `toString()` coloré (cli-color) qui adapte le format selon
+ *   l'environnement (production = message court ; dev = champs détaillés).
+ *
+ * @example Wrap d'une erreur existante
+ * ```ts
+ * try { ... } catch (e) { throw new nodefonyError(e, 500); }
+ * ```
+ *
+ * @example Erreur custom
+ * ```ts
+ * throw new nodefonyError("user not found", 404);
+ * ```
+ *
+ * @remarks Les erreurs de bibliothèques tierces (drivers ORM…) sont reconnues
+ *   et formatées via un adapter injecté par `registerErrorAdapter` — le core
+ *   reste découplé des modules. Sans adapter enregistré, l'erreur retombe sur la
+ *   classification générique.
+ */
+declare class nodefonyError extends Error {
+    #private;
+    code: number | null;
+    error?: Error;
+    errorType: string;
+    [key: string]: any;
+    /**
+     * Sérialisation JSON filtrée — POSÉE sur le prototype plus bas
+     * (`Object.defineProperty(nodefonyError.prototype, "toJSON", …)`), donc
+     * déclarée ici sans initialiseur (`declare` : aucun code émis).
+     *
+     * Sur `Error`, la même méthode est déclarée **optionnelle** : elle
+     * n'appartient pas au type standard, et l'imposer rendrait incompilable toute
+     * classe tierce qui écrit `implements Error` (cf `types/globals.ts`). Sur
+     * `nodefonyError`, elle est CERTAINE — c'est la classe qui la garantit.
+     */
+    toJSON: () => Record<string, any>;
+    /**
+     * @param message - string ou `Error` natif à wrapper. Si Error, ses champs
+     *   (message, code, stack) sont copiés ; le type est détecté.
+     * @param code - statut HTTP ou code custom (utilisé par HttpError pour le
+     *   status code de la réponse).
+     */
+    constructor(message?: string | Error, code?: number);
+    /**
+     * Type guard — vérifie qu'une valeur est une instance d'`Error`.
+     *
+     * Override de la méthode native ajoutée par TS 6 ; conserve la signature
+     * pour rester compatible avec les consommateurs qui utilisent `Error.isError`.
+     *
+     * @param error - valeur inconnue à tester.
+     * @returns `true` si `error instanceof Error`.
+     */
+    static isError(error: unknown): error is Error;
+    /**
+     * Détecte la catégorie d'une erreur (TypeError, SystemError, OrmError, etc.).
+     *
+     * Utilisée par `getType()` pour peupler `errorType` et copier les champs
+     * spécifiques au type (errno, syscall, bytesParsed, etc.).
+     *
+     * @param error - instance d'`Error` à classifier.
+     * @returns nom de la catégorie ou `false` si pas une `Error`.
+     */
+    static detectType(error: Error): string | false;
+    /**
+     * Détecte le type d'erreur et copie ses champs spécifiques sur `this`.
+     *
+     * Côté SystemError → `errno/syscall/address/port` ; AssertionError →
+     * `actual/expected/operator` ; ClientError → `bytesParsed/rawPacket`, etc.
+     *
+     * @param error - erreur source à analyser.
+     * @returns nom de la catégorie (jamais `false` — fallback `error.constructor.name` ou `"Error"`).
+     */
+    getType(error: Error): string;
+    /**
+     * Sérialise l'erreur en string coloré (cli-color) selon `errorType` et l'environnement.
+     *
+     * En **production**, retourne un message court (type + message) ; sinon, formatage
+     * détaillé multi-lignes. Ajoute la stack si `kernel.debug` est actif.
+     *
+     * ⚠️ La garde compare à `"production"` **en toutes lettres**. Elle a longtemps
+     * comparé à `"prod"` — jamais vraie : `Kernel.setEnv()` réduit toujours
+     * l'environnement à `"development" | "production"` (`resolveRuntimeEnv`), même
+     * quand l'utilisateur a écrit `prod`. Le format court n'était donc jamais rendu.
+     *
+     * @returns string formatée prête pour `console.log` ou syslog.
+     */
+    toString(): string;
+    /**
+     * Parse l'argument du constructeur et hydrate les champs (`message`, `code`, `stack`).
+     *
+     * Trois cas : `Error` natif (copie message/code/stack), `object` (extrait
+     * `status/code/message` + capture stack), autre (fallback `getDefaultMessage`).
+     *
+     * @param message - string, `Error`, ou objet quelconque à interpréter.
+     */
+    parseMessage(message: any): void;
+    /**
+     * Renseigne `this.message` à partir du `code` HTTP via `STATUS_CODES`.
+     *
+     * Fallback quand aucun message n'est fourni mais qu'un code est connu —
+     * ex : `new nodefonyError(undefined, 404)` → message `"Not Found"`.
+     */
+    getDefaultMessage(): void;
+    /**
+     * Affiche l'erreur formatée sur `console.log` (raccourci de `toString()`).
+     *
+     * @returns `undefined` — `console.log` ne retourne rien.
+     */
+    logger(): void;
+}
+export default nodefonyError;