@visulima/pail 3.2.0 → 3.2.2

package/dist/types.d.ts

@@ -0,0 +1,241 @@
+import type { AnsiColors } from "@visulima/colorize";
+import type { stringify } from "safe-stable-stringify";
+import type { LiteralUnion, Primitive } from "type-fest";
+import type InteractiveManager from "./interactive/interactive-manager.d.ts";
+/**
+ * Global namespace for extending Pail's metadata interface.
+ *
+ * This global declaration allows other packages and applications to extend
+ * the Meta interface with custom properties by declaring additional properties
+ * in the VisulimaPail.CustomMeta interface.
+ * @example
+ * ```typescript
+ * declare global {
+ *   namespace VisulimaPail {
+ *     interface CustomMeta<L> {
+ *       userId?: string;
+ *       requestId?: string;
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare global {
+    namespace VisulimaPail {
+        interface CustomMeta<L> {
+        }
+    }
+}
+/**
+ * Metadata object containing all information about a log entry.
+ *
+ * This interface defines the structure of metadata that is passed to reporters
+ * and processors. It contains all the contextual information about a log message
+ * including the message itself, timing information, error details, and more.
+ * @template L - The log level type
+ */
+export interface Meta<L> extends VisulimaPail.CustomMeta<L> {
+    badge: string | undefined;
+    context: any[] | undefined;
+    date: Date | string;
+    error: Error | undefined;
+    groups: string[];
+    label: string | undefined;
+    message: Primitive | ReadonlyArray<unknown> | Record<PropertyKey, unknown>;
+    prefix: string | undefined;
+    repeated?: number | undefined;
+    scope: string[] | undefined;
+    suffix: string | undefined;
+    traceError: Error | undefined;
+    type: {
+        level: ExtendedRfc5424LogLevels | L;
+        name: string;
+    };
+}
+/**
+ * Extended RFC 5424 Log Levels.
+ *
+ * Standard syslog severity levels as defined in RFC 5424, plus additional
+ * levels commonly used in modern applications. Each level has a numeric
+ * priority where lower numbers indicate higher severity.
+ * @see https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
+ */
+export type ExtendedRfc5424LogLevels = "alert" | "critical" | "debug" | "emergency" | "error" | "informational" | "notice" | "trace" | "warning";
+/**
+ * Default Log Types.
+ *
+ * Predefined semantic log types that provide meaningful categorization
+ * for different kinds of log messages. Each type has associated styling
+ * and log level configuration.
+ */
+export type DefaultLogTypes = "alert" | "await" | "complete" | "critical" | "debug" | "emergency" | "error" | "info" | "log" | "notice" | "pending" | "start" | "stop" | "success" | "trace" | "wait" | "warn" | "warning" | "watch";
+/**
+ * Logger Function Type.
+ *
+ * Represents a logging function that can accept either a structured Message object
+ * or multiple arguments in the traditional console.log style.
+ */
+export interface LoggerFunction {
+    (message: Message): void;
+    (...message: any[]): void;
+}
+/**
+ * Logger Configuration.
+ *
+ * Configuration object that defines how a specific logger type should behave,
+ * including its visual appearance and log level.
+ * @template L - The log level type
+ */
+export interface LoggerConfiguration<L extends string> {
+    badge?: string;
+    color?: AnsiColors | undefined;
+    label: string;
+    logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>;
+}
+/**
+ * Logger Types Configuration.
+ *
+ * A record mapping logger type names to their configurations.
+ * @template T - Custom logger type names
+ * @template L - Log level types
+ */
+export type LoggerTypesConfig<T extends string, L extends string> = Record<T, Partial<LoggerConfiguration<L>>>;
+/**
+ * Default Logger Types Configuration.
+ *
+ * A complete mapping of all default log types to their full configurations.
+ * @template L - Log level types
+ */
+export type DefaultLoggerTypes<L extends string = string> = Record<DefaultLogTypes, LoggerConfiguration<L>>;
+/**
+ * Read-only Metadata.
+ *
+ * Immutable version of the Meta interface for use in reporters.
+ * @template L - The log level type
+ */
+export type ReadonlyMeta<L extends string> = Readonly<Meta<L>>;
+/**
+ * Reporter Interface.
+ *
+ * Base interface for all reporters. Reporters are responsible for
+ * outputting log messages to various destinations (console, files, etc.).
+ * @template L - The log level type
+ */
+export interface Reporter<L extends string> {
+    log: (meta: ReadonlyMeta<L>) => void;
+}
+/**
+ * Stream-Aware Reporter Interface.
+ *
+ * Extends Reporter with the ability to work with Node.js streams.
+ * Used for server-side reporters that need to write to stdout/stderr.
+ * @template L - The log level type
+ */
+export interface StreamAwareReporter<L extends string> extends Reporter<L> {
+    /** Set the stderr stream for error output */
+    setStderr: (stderr: NodeJS.WriteStream) => void;
+    /** Set the stdout stream for standard output */
+    setStdout: (stdout: NodeJS.WriteStream) => void;
+}
+/**
+ * Logger Types Aware Reporter Interface.
+ *
+ * Extends Reporter with the ability to receive logger type configurations.
+ * Allows reporters to customize their output based on logger types.
+ * @template T - Custom logger type names
+ * @template L - The log level type
+ */
+export interface LoggerTypesAwareReporter<T extends string, L extends string> extends Reporter<L> {
+    /** Set the logger types configuration */
+    setLoggerTypes: (types: LoggerTypesConfig<T, L> & Partial<LoggerTypesConfig<DefaultLogTypes, L>>) => void;
+}
+/**
+ * Stringify-Aware Reporter Interface.
+ *
+ * Extends Reporter with the ability to receive a custom stringify function.
+ * Useful for reporters that need to serialize complex objects.
+ * @template L - The log level type
+ */
+export interface StringifyAwareReporter<L extends string> extends Reporter<L> {
+    /** Set the stringify function for object serialization */
+    setStringify: (stringify: typeof JSON.stringify) => void;
+}
+/**
+ * Interactive Stream Reporter Interface.
+ *
+ * Extends StreamAwareReporter with interactive capabilities for terminal UIs.
+ * Supports features like progress bars and dynamic updates.
+ * @template L - The log level type
+ */
+export interface InteractiveStreamReporter<L extends string> extends StreamAwareReporter<L> {
+    /** Set the interactive manager for handling interactive output */
+    setInteractiveManager: (manager?: InteractiveManager) => void;
+    /** Enable or disable interactive mode */
+    setIsInteractive: (interactive: boolean) => void;
+}
+/**
+ * Processor Interface.
+ *
+ * Base interface for all processors. Processors can modify or enhance
+ * log metadata before it reaches reporters.
+ * @template L - The log level type
+ */
+export interface Processor<L extends string> {
+    /** Process the log metadata */
+    process: (meta: Meta<L>) => Meta<L>;
+}
+/**
+ * Stringify-Aware Processor Interface.
+ *
+ * Extends Processor with the ability to receive a custom stringify function.
+ * Useful for processors that need to serialize complex objects.
+ * @template L - The log level type
+ */
+export interface StringifyAwareProcessor<L extends string> extends Processor<L> {
+    /** Set the stringify function for object serialization */
+    setStringify: (stringify: typeof JSON.stringify) => void;
+}
+export interface ConstructorOptions<T extends string, L extends string> {
+    disabled?: boolean;
+    logLevel?: LiteralUnion<ExtendedRfc5424LogLevels, L>;
+    logLevels?: Partial<Record<ExtendedRfc5424LogLevels, number>> & Record<L, number>;
+    messages?: {
+        timerEnd?: string;
+        timerStart?: string;
+    };
+    processors?: Processor<L>[];
+    rawReporter?: Reporter<L>;
+    reporters?: Reporter<L>[];
+    scope?: string[] | string;
+    throttle?: number;
+    throttleMin?: number;
+    types?: LoggerTypesConfig<T, L> & Partial<LoggerTypesConfig<DefaultLogTypes, L>>;
+}
+export interface ServerConstructorOptions<T extends string, L extends string> extends ConstructorOptions<T, L> {
+    interactive?: boolean;
+    stderr: NodeJS.WriteStream;
+    stdout: NodeJS.WriteStream;
+}
+export type Message = {
+    context?: any[] | undefined;
+    message: any;
+    prefix?: string;
+    suffix?: string;
+};
+/**
+ * Internal interface for parent logger optimization properties.
+ *
+ * These properties are used internally to optimize child logger creation
+ * by reusing parent logger's computed values when they haven't changed.
+ * @internal
+ */
+export interface ParentLoggerOptimization<T extends string = string, L extends string = string> {
+    parentLogLevels?: Record<string, number>;
+    parentLongestLabel?: string;
+    parentMessages?: {
+        timerEnd: string;
+        timerStart: string;
+    };
+    parentStringify?: typeof stringify;
+    parentTypes?: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
+}

package/dist/utils/ansi-escapes.d.ts

@@ -0,0 +1,4 @@
+export declare const clearTerminal: string;
+export declare const cursorHide: string;
+export declare const cursorShow: string;
+export declare const eraseLines: (count: number) => string;

package/dist/utils/arrayify.d.ts

@@ -0,0 +1,2 @@
+declare const arrayify: <T>(x: T | T[]) => T[];
+export default arrayify;

package/dist/utils/get-longest-badge.d.ts

@@ -0,0 +1,4 @@
+import type { LiteralUnion } from "type-fest";
+import type { DefaultLogTypes, LoggerTypesConfig } from "../types.d.ts";
+declare const getLongestBadge: <L extends string, T extends string>(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>) => string;
+export default getLongestBadge;

package/dist/utils/get-longest-label.d.ts

@@ -0,0 +1,4 @@
+import type { LiteralUnion } from "type-fest";
+import type { DefaultLogTypes, LoggerTypesConfig } from "../types.d.ts";
+declare const getLongestLabel: <L extends string, T extends string>(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>) => string;
+export default getLongestLabel;

package/dist/utils/merge-types.d.ts

@@ -0,0 +1,4 @@
+import type { LiteralUnion } from "type-fest";
+import type { DefaultLoggerTypes, DefaultLogTypes, LoggerTypesConfig } from "../types.d.ts";
+declare const mergeTypes: <L extends string, T extends string>(standard: DefaultLoggerTypes<L>, custom: LoggerTypesConfig<T, L>) => LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
+export default mergeTypes;

package/dist/utils/stream/safe-stream-handler.d.ts

@@ -0,0 +1,21 @@
+import type { Writable } from "node:stream";
+/**
+ * A handler for writable streams that only writes if the stream has finished
+ * processing or draining
+ */
+declare class SafeStreamHandler {
+    #private;
+    constructor(stream: Writable, name: string);
+    /**
+     * Writes `message` to the instance's internal stream.
+     * @param message Message to write
+     */
+    write(message: string): void;
+    /**
+     * Calls `end` on this instance's internal stream
+     */
+    end(...arguments_: any[]): void;
+    get isReady(): boolean;
+    protected writeStream(message: string): void;
+}
+export default SafeStreamHandler;

package/dist/utils/write-console-log-based-on-level.d.ts

@@ -0,0 +1,4 @@
+import type { LiteralUnion } from "type-fest";
+import type { ExtendedRfc5424LogLevels } from "../types.d.ts";
+declare const writeConsoleLogBasedOnLevel: <L extends string = string>(level: LiteralUnion<ExtendedRfc5424LogLevels, L>) => (...data: any[]) => void;
+export default writeConsoleLogBasedOnLevel;

package/dist/utils/write-stream.d.ts

@@ -0,0 +1,2 @@
+declare const writeStream: (data: string, stream: NodeJS.WriteStream) => boolean;
+export default writeStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/pail",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "Highly configurable Logger for Node.js, Edge and Browser.",
   "keywords": [
     "ansi",
@@ -203,12 +203,11 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@visulima/colorize": "1.4.27",
-    "type-fest": "^5.2.0"
+    "@visulima/colorize": "1.4.29"
   },
   "peerDependencies": {
     "@opentelemetry/api": "^1.9",
-    "@visulima/redact": "2.0.3",
+    "@visulima/redact": "2.0.5",
     "rotating-file-stream": "^3.2.7"
   },
   "peerDependenciesMeta": {

package/dist/packem_shared/abstract-json-reporter-DiyVyU0j.d.ts

@@ -1,22 +0,0 @@
-import { s as stringify } from './index.d-oxZvg_y7.js';
-import { LiteralUnion } from 'type-fest';
-import { f as StringifyAwareReporter, e as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from './types-D3ycu8-x.js';
-
-type AbstractJsonReporterOptions = {
-    error: Partial<{
-        exclude?: string[];
-        maxDepth?: number;
-        useToJSON?: boolean;
-    }>;
-};
-declare abstract class AbstractJsonReporter<L extends string = string> implements StringifyAwareReporter<L> {
-    protected stringify: typeof stringify | undefined;
-    protected errorOptions: AbstractJsonReporterOptions["error"];
-    constructor(options?: Partial<AbstractJsonReporterOptions>);
-    setStringify(function_: any): void;
-    log(meta: ReadonlyMeta<L>): void;
-    protected abstract _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-
-export { AbstractJsonReporter as A };
-export type { AbstractJsonReporterOptions as a };

package/dist/packem_shared/abstract-pretty-reporter-BbOWXMCs.d.ts

@@ -1,28 +0,0 @@
-import { LiteralUnion } from 'type-fest';
-import { c as LoggerTypesAwareReporter, d as LoggerTypesConfig, a as DefaultLogTypes, e as ReadonlyMeta } from './types-D3ycu8-x.js';
-
-declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
-    protected readonly styles: PrettyStyleOptions;
-    protected loggerTypes: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
-    protected constructor(options: Partial<PrettyStyleOptions>);
-    setLoggerTypes(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>): void;
-    abstract log(meta: ReadonlyMeta<L>): void;
-}
-type PrettyStyleOptions = {
-    bold: {
-        label: boolean;
-    };
-    dateFormatter: (date: Date) => string;
-    messageLength: number | undefined;
-    underline: {
-        label: boolean;
-        prefix: boolean;
-        suffix: boolean;
-    };
-    uppercase: {
-        label: boolean;
-    };
-};
-
-export { AbstractPrettyReporter as A };
-export type { PrettyStyleOptions as P };

package/dist/packem_shared/index.d-BR1GjZri.d.ts

@@ -1,53 +0,0 @@
-import { LiteralUnion } from 'type-fest';
-
-type ColorizeMethod = (value: string) => string;
-type CodeFrameOptions = {
-    color?: {
-        gutter?: ColorizeMethod;
-        marker?: ColorizeMethod;
-        message?: ColorizeMethod;
-    };
-    linesAbove?: number;
-    linesBelow?: number;
-    message?: string;
-    prefix?: string;
-    showGutter?: boolean;
-    showLineNumbers?: boolean;
-    tabWidth?: number | false;
-};
-
-type Options$1 = Omit<CodeFrameOptions, "message | prefix"> & {
-    color: CodeFrameOptions["color"] & {
-        fileLine: ColorizeMethod;
-        hint: ColorizeMethod;
-        method: ColorizeMethod;
-        title: ColorizeMethod;
-    };
-    cwd: string;
-    displayShortPath: boolean;
-    filterStacktrace: ((line: string) => boolean) | undefined;
-    framesMaxLimit: number;
-    hideErrorCauseCodeView: boolean;
-    hideErrorCodeView: boolean;
-    hideErrorErrorsCodeView: boolean;
-    hideErrorTitle: boolean;
-    hideMessage: boolean;
-    indentation: number | "\t";
-    prefix: string;
-};
-
-interface Options {
-    breakLength: number;
-    customInspect: boolean;
-    depth: number;
-    indent: number | "\t" | undefined;
-    maxArrayLength: number;
-    numericSeparator: boolean;
-    quoteStyle: "double" | "single";
-    showHidden: boolean;
-    showProxy: boolean;
-    stylize: <S extends string>(value: S, styleType: LiteralUnion<"bigint" | "boolean" | "date" | "null" | "number" | "regexp" | "special" | "string" | "symbol" | "undefined", string>) => string;
-    truncate: number;
-}
-
-export type { Options$1 as O, Options as a };

package/dist/packem_shared/index.d-oxZvg_y7.d.ts

@@ -1,20 +0,0 @@
-type Replacer = (number | string)[] | null | undefined | ((key: string, value: unknown) => string | number | boolean | null | object)
-
-interface StringifyOptions {
-  bigint?: boolean,
-  circularValue?: string | null | TypeErrorConstructor | ErrorConstructor,
-  deterministic?: boolean | ((a: string, b: string) => number),
-  maximumBreadth?: number,
-  maximumDepth?: number,
-  strict?: boolean,
-}
-
-declare function stringify(value: undefined | symbol | ((...args: unknown[]) => unknown), replacer?: Replacer, space?: string | number): undefined
-declare function stringify(value: string | number | unknown[] | null | boolean | object, replacer?: Replacer, space?: string | number): string
-declare function stringify(value: unknown, replacer?: ((key: string, value: unknown) => unknown) | (number | string)[] | null | undefined, space?: string | number): string | undefined
-
-declare namespace stringify {
-  export function configure(options: StringifyOptions): typeof stringify
-}
-
-export { stringify as s };

package/dist/packem_shared/pail.browser-By9KjOH7.d.ts

@@ -1,69 +0,0 @@
-import { s as stringify } from './index.d-oxZvg_y7.js';
-import { LiteralUnion } from 'type-fest';
-import { C as ConstructorOptions, M as Meta, a as DefaultLogTypes, d as LoggerTypesConfig, P as Processor, E as ExtendedRfc5424LogLevels, R as Reporter, b as LoggerFunction } from './types-D3ycu8-x.js';
-
-declare class PailBrowserImpl<T extends string = string, L extends string = string> {
-    #private;
-    protected timersMap: Map<string, number>;
-    protected countMap: Map<string, number>;
-    protected seqTimers: Set<string>;
-    protected readonly lastLog: {
-        count?: number;
-        object?: Meta<L>;
-        time?: Date;
-        timeout?: ReturnType<typeof setTimeout>;
-    };
-    protected readonly logLevels: Record<string, number>;
-    protected disabled: boolean;
-    protected paused: boolean;
-    protected messageQueue: {
-        messageObject: any[];
-        raw: boolean;
-        type: LiteralUnion<DefaultLogTypes, T>;
-    }[];
-    protected scopeName: string[];
-    protected readonly types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
-    protected readonly longestLabel: string;
-    protected readonly processors: Set<Processor<L>>;
-    protected readonly generalLogLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>;
-    protected reporters: Set<Reporter<L>>;
-    protected readonly throttle: number;
-    protected readonly throttleMin: number;
-    protected readonly stringify: typeof stringify;
-    protected groups: string[];
-    protected readonly startTimerMessage: string;
-    protected readonly endTimerMessage: string;
-    protected rawReporter: Reporter<L>;
-    protected force: Record<string, LoggerFunction>;
-    constructor(options: ConstructorOptions<T, L>);
-    wrapConsole(): void;
-    restoreConsole(): void;
-    wrapException(): void;
-    disable(): void;
-    enable(): void;
-    isEnabled(): boolean;
-    pause(): void;
-    resume(): void;
-    scope<N extends string = T>(...name: string[]): PailBrowserType<N, L>;
-    unscope(): void;
-    child<N extends string = T, LC extends string = L>(options?: Partial<ConstructorOptions<N, LC>>): PailBrowserType<N, LC>;
-    time(label?: string): void;
-    timeLog(label?: string, ...data: unknown[]): void;
-    timeEnd(label?: string): void;
-    group(label?: string): void;
-    groupEnd(): void;
-    count(label?: string): void;
-    countReset(label?: string): void;
-    clear(): void;
-    raw(message: string, ...arguments_: unknown[]): void;
-    protected extendReporter(reporter: Reporter<L>): Reporter<L>;
-    protected registerReporters(reporters: Reporter<L>[]): void;
-    protected registerProcessors(processors: Processor<L>[]): void;
-    protected logger(type: LiteralUnion<DefaultLogTypes, T>, raw: boolean, force: boolean, ...messageObject: any[]): void;
-}
-type PailBrowserType<T extends string = string, L extends string = string> = Console & (new <TC extends string = string, LC extends string = string>(options?: ConstructorOptions<TC, LC>) => PailBrowserType<TC, LC>) & PailBrowserImpl<T, L> & Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction> & {
-    force: Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction>;
-};
-
-export { PailBrowserImpl as a };
-export type { PailBrowserType as P };

package/dist/packem_shared/types-D3ycu8-x.d.ts

@@ -1,95 +0,0 @@
-import { AnsiColors } from '@visulima/colorize';
-import { LiteralUnion, Primitive } from 'type-fest';
-import { InteractiveManager } from '../interactive/index.js';
-
-declare global {
-    namespace VisulimaPail {
-        interface CustomMeta<L> {
-        }
-    }
-}
-interface Meta<L> extends VisulimaPail.CustomMeta<L> {
-    badge: string | undefined;
-    context: any[] | undefined;
-    date: Date | string;
-    error: Error | undefined;
-    groups: string[];
-    label: string | undefined;
-    message: Primitive | ReadonlyArray<unknown> | Record<PropertyKey, unknown>;
-    prefix: string | undefined;
-    repeated?: number | undefined;
-    scope: string[] | undefined;
-    suffix: string | undefined;
-    traceError: Error | undefined;
-    type: {
-        level: ExtendedRfc5424LogLevels | L;
-        name: string;
-    };
-}
-type ExtendedRfc5424LogLevels = "alert" | "critical" | "debug" | "emergency" | "error" | "informational" | "notice" | "trace" | "warning";
-type DefaultLogTypes = "alert" | "await" | "complete" | "critical" | "debug" | "emergency" | "error" | "info" | "log" | "notice" | "pending" | "start" | "stop" | "success" | "trace" | "wait" | "warn" | "warning" | "watch";
-interface LoggerFunction {
-    (message: Message): void;
-    (...message: any[]): void;
-}
-interface LoggerConfiguration<L extends string> {
-    badge?: string;
-    color?: AnsiColors | undefined;
-    label: string;
-    logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>;
-}
-type LoggerTypesConfig<T extends string, L extends string> = Record<T, Partial<LoggerConfiguration<L>>>;
-type DefaultLoggerTypes<L extends string = string> = Record<DefaultLogTypes, LoggerConfiguration<L>>;
-type ReadonlyMeta<L extends string> = Readonly<Meta<L>>;
-interface Reporter<L extends string> {
-    log: (meta: ReadonlyMeta<L>) => void;
-}
-interface StreamAwareReporter<L extends string> extends Reporter<L> {
-    setStderr: (stderr: NodeJS.WriteStream) => void;
-    setStdout: (stdout: NodeJS.WriteStream) => void;
-}
-interface LoggerTypesAwareReporter<T extends string, L extends string> extends Reporter<L> {
-    setLoggerTypes: (types: LoggerTypesConfig<T, L> & Partial<LoggerTypesConfig<DefaultLogTypes, L>>) => void;
-}
-interface StringifyAwareReporter<L extends string> extends Reporter<L> {
-    setStringify: (stringify: typeof JSON.stringify) => void;
-}
-interface InteractiveStreamReporter<L extends string> extends StreamAwareReporter<L> {
-    setInteractiveManager: (manager?: InteractiveManager) => void;
-    setIsInteractive: (interactive: boolean) => void;
-}
-interface Processor<L extends string> {
-    process: (meta: Meta<L>) => Meta<L>;
-}
-interface StringifyAwareProcessor<L extends string> extends Processor<L> {
-    setStringify: (stringify: typeof JSON.stringify) => void;
-}
-interface ConstructorOptions<T extends string, L extends string> {
-    disabled?: boolean;
-    logLevel?: LiteralUnion<ExtendedRfc5424LogLevels, L>;
-    logLevels?: Partial<Record<ExtendedRfc5424LogLevels, number>> & Record<L, number>;
-    messages?: {
-        timerEnd?: string;
-        timerStart?: string;
-    };
-    processors?: Processor<L>[];
-    rawReporter?: Reporter<L>;
-    reporters?: Reporter<L>[];
-    scope?: string[] | string;
-    throttle?: number;
-    throttleMin?: number;
-    types?: LoggerTypesConfig<T, L> & Partial<LoggerTypesConfig<DefaultLogTypes, L>>;
-}
-interface ServerConstructorOptions<T extends string, L extends string> extends ConstructorOptions<T, L> {
-    interactive?: boolean;
-    stderr: NodeJS.WriteStream;
-    stdout: NodeJS.WriteStream;
-}
-type Message = {
-    context?: any[] | undefined;
-    message: any;
-    prefix?: string;
-    suffix?: string;
-};
-
-export type { ConstructorOptions as C, DefaultLoggerTypes as D, ExtendedRfc5424LogLevels as E, InteractiveStreamReporter as I, LoggerConfiguration as L, Meta as M, Processor as P, Reporter as R, StreamAwareReporter as S, DefaultLogTypes as a, LoggerFunction as b, LoggerTypesAwareReporter as c, LoggerTypesConfig as d, ReadonlyMeta as e, StringifyAwareReporter as f, ServerConstructorOptions as g, StringifyAwareProcessor as h };