@visulima/pail 4.0.0-alpha.11 → 4.0.0-alpha.13

package/dist/reporter/http/http-reporter.js

@@ -1,13 +1 @@
-import { AbstractHttpReporter } from './abstract-http-reporter.js';
-
-class HttpReporter extends AbstractHttpReporter {
-  /**
-   * Creates a new HTTP Reporter instance.
-   * @param options Configuration options for HTTP reporting
-   */
-  constructor(options) {
-    super(options);
-  }
-}
-
-export { HttpReporter as default };
+var a=Object.defineProperty;var r=(e,t)=>a(e,"name",{value:t,configurable:!0});import{AbstractHttpReporter as s}from"./abstract-http-reporter.js";var o=Object.defineProperty,p=r((e,t)=>o(e,"name",{value:t,configurable:!0}),"e");class i extends s{static{r(this,"s")}static{p(this,"HttpReporter")}constructor(t){super(t)}}export{i as default};

package/dist/reporter/json/index.browser.d.ts

@@ -1,3 +1,99 @@
-export type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
-export { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
-export { default as JsonReporter } from "./json-reporter.d.ts";
+import { stringify } from 'safe-stable-stringify';
+import { LiteralUnion } from 'type-fest';
+import { R as ReadonlyMeta, E as ExtendedRfc5424LogLevels, S as StringifyAwareReporter } from "../../packem_shared/types.d-C51XNfQz.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* Options for configuring JSON reporters.
+*/
+type AbstractJsonReporterOptions = {
+  /** Error serialization options */
+  error: Partial<{
+    /** Properties to exclude from error serialization */
+    exclude?: string[];
+    /** Maximum depth for error object serialization */
+    maxDepth?: number;
+    /** Whether to use toJSON methods during serialization */
+    useToJSON?: boolean;
+  }>;
+};
+/**
+* Abstract JSON Reporter.
+*
+* Base class for JSON-based reporters that provides common functionality
+* for serializing log metadata to JSON format. Handles error serialization,
+* context processing, and provides a template method for actual output.
+* @template L - The log level type
+* @example
+* ```typescript
+* class CustomJsonReporter extends AbstractJsonReporter {
+*   protected _log(message: string): void {
+*     console.log(message);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractJsonReporter<L extends string = string> implements StringifyAwareReporter<L> {
+  /** Custom stringify function for object serialization */
+  protected stringify: typeof stringify | undefined;
+  /** Error serialization options */
+  protected errorOptions: AbstractJsonReporterOptions["error"];
+  /**
+  * Creates a new AbstractJsonReporter instance.
+  * @param options Configuration options for JSON formatting and error handling
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Sets a custom stringify function for object serialization.
+  * @param function_ The stringify function to use for serialization
+  */
+  setStringify(function_: typeof stringify): void;
+  log(meta: ReadonlyMeta<L>): void;
+  /**
+  * Template method for outputting the JSON log message.
+  *
+  * Subclasses must implement this method to define how the JSON message
+  * is actually written (to console, file, network, etc.).
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level of the message
+  * @protected
+  * @abstract
+  */
+  protected abstract _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+/**
+* Browser JSON Reporter.
+*
+* A JSON reporter for browser environments that outputs structured log data
+* to the browser console. Uses appropriate console methods based on log level.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new JsonReporter()]
+* });
+*
+* logger.info("Application started", { version: "1.0.0" });
+* // Outputs: {"level":"info","message":"Application started","context":[{"version":"1.0.0"}],...}
+* ```
+*/
+declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> {
+  /**
+  * Creates a new Browser JSON Reporter instance.
+  * @param options Configuration options for JSON formatting
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Outputs the JSON message to the browser console.
+  *
+  * Uses the appropriate console method based on the log level
+  * (console.log, console.error, console.warn, etc.).
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level determining which console method to use
+  * @protected
+  */
+  protected override _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export { AbstractJsonReporter, type AbstractJsonReporterOptions, JsonReporter };

package/dist/reporter/json/index.browser.js

@@ -1,2 +1 @@
-export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-BO8Calb4.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-CCmj7oYL.js';
+import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-Dt5-5x2R.js";import{default as p}from"../../packem_shared/JsonReporter-CerNvhg-.js";export{e as AbstractJsonReporter,p as JsonReporter};

package/dist/reporter/json/index.d.ts

@@ -1,3 +1,51 @@
-export type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
-export { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
-export { default as JsonReporter } from "./json-reporter.d.ts";
+import { A as AbstractJsonReporterOptions, a as AbstractJsonReporter } from "../../packem_shared/abstract-json-reporter.d-Bz3lZEDi.js";
+import { E as ExtendedRfc5424LogLevels, L as LiteralUnion, a as StreamAwareReporter } from "../../packem_shared/types.d-ByY2ZuYG.js";
+import 'safe-stable-stringify';
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* Server JSON Reporter.
+*
+* A JSON reporter for Node.js server environments that outputs structured log data
+* to stdout/stderr streams. Routes error-level logs to stderr and others to stdout.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new JsonReporter()]
+* });
+*
+* logger.info("Server started", { port: 3000 });
+* logger.error("Database connection failed", error);
+* ```
+*/
+declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> implements StreamAwareReporter<L> {
+  #private;
+  /**
+  * Creates a new Server JSON Reporter instance.
+  * @param options Configuration options for JSON formatting
+  */
+  constructor(options?: Partial<AbstractJsonReporterOptions>);
+  /**
+  * Sets the stdout stream for the reporter.
+  * @param stdout_ The writable stream to use for stdout output
+  */
+  setStdout(stdout_: NodeJS.WriteStream): void;
+  /**
+  * Sets the stderr stream for the reporter.
+  * @param stderr_ The writable stream to use for stderr output
+  */
+  setStderr(stderr_: NodeJS.WriteStream): void;
+  /**
+  * Outputs the JSON message to the appropriate stream.
+  *
+  * Routes error and warning level messages to stderr, others to stdout.
+  * @param message The JSON-formatted log message
+  * @param logLevel The log level determining which stream to use
+  * @protected
+  */
+  protected override _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export { AbstractJsonReporter, type AbstractJsonReporterOptions, JsonReporter };

package/dist/reporter/json/index.js

@@ -1,2 +1 @@
-export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-nOj0Ft1F.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-Ck2PIAEw.js';
+import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-BawNFYxI.js";import{default as p}from"../../packem_shared/JsonReporter-15ln04rX.js";export{e as AbstractJsonReporter,p as JsonReporter};

package/dist/reporter/pretty/index.browser.d.ts

@@ -1,2 +1,106 @@
-export type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
-export { default as PrettyReporter } from "./pretty-reporter.d.ts";
+import { LiteralUnion } from 'type-fest';
+import { D as DefaultLogTypes, L as LoggerTypesConfig, R as ReadonlyMeta, a as LoggerTypesAwareReporter } from "../../packem_shared/types.d-C51XNfQz.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* Abstract Pretty Reporter.
+*
+* Base class for pretty-printing reporters that format log messages with colors,
+* styles, and structured layout. Provides common functionality for styling options
+* and logger type configuration.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* class CustomPrettyReporter extends AbstractPrettyReporter {
+*   public log(meta: ReadonlyMeta) {
+*     const formatted = this.formatMessage(meta);
+*     console.log(formatted);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
+  /** Styling options for pretty formatting */
+  protected readonly styles: PrettyStyleOptions;
+  /** Logger type configurations for styling */
+  protected loggerTypes: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
+  /**
+  * Creates a new AbstractPrettyReporter instance.
+  * @param options Styling options for pretty formatting
+  * @protected
+  */
+  protected constructor(options: Partial<PrettyStyleOptions>);
+  /**
+  * Sets the logger types configuration for styling.
+  * @param types Logger type configurations with colors and labels
+  */
+  setLoggerTypes(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>): void;
+  /**
+  * Logs a message with pretty formatting.
+  * @param meta The log metadata to format and output
+  * @abstract
+  */
+  abstract log(meta: ReadonlyMeta<L>): void;
+}
+/**
+* Options for configuring pretty reporter styling.
+*/
+type PrettyStyleOptions = {
+  /** Bold styling options */
+  bold: {
+    /** Whether to bold the label text */
+    label: boolean;
+  };
+  /** Function to format dates in log output */
+  dateFormatter: (date: Date) => string;
+  /** Maximum length of message before line break (optional) */
+  messageLength: number | undefined;
+  /** Underline styling options */
+  underline: {
+    /** Whether to underline the label */
+    label: boolean;
+    /** Whether to underline prefixes */
+    prefix: boolean;
+    /** Whether to underline suffixes */
+    suffix: boolean;
+  };
+  /** Uppercase styling options */
+  uppercase: {
+    /** Whether to uppercase the label text */
+    label: boolean;
+  };
+};
+/**
+* Browser Pretty Reporter.
+*
+* A pretty-printing reporter for browser environments that formats log messages
+* with colors and structured layout for console output. Uses browser-compatible
+* color formatting and console APIs.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new PrettyReporter({
+*     bold: { label: true },
+*     uppercase: { label: true }
+*   })]
+* });
+*
+* logger.info("Application started");
+* logger.error("Something went wrong", error);
+* ```
+*/
+declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> {
+  #private;
+  /**
+  * Creates a new Browser Pretty Reporter instance.
+  * @param options Styling options for pretty formatting
+  */
+  constructor(options?: Partial<PrettyStyleOptions>);
+  log(meta: ReadonlyMeta<L>): void;
+}
+export { PrettyReporter, type PrettyStyleOptions };

package/dist/reporter/pretty/index.browser.js

@@ -1 +1 @@
-export { default as PrettyReporter } from '../../packem_shared/PrettyReporter-BtTr13Ha.js';
+import{default as t}from"../../packem_shared/PrettyReporter-Br5njEEy.js";export{t as PrettyReporter};

package/dist/reporter/pretty/index.d.ts

@@ -1,2 +1,186 @@
-export type { PrettyReporterOptions } from "./pretty-reporter.d.ts";
-export { PrettyReporter } from "./pretty-reporter.d.ts";
+import { RenderErrorOptions } from '@visulima/error/error';
+import { InteractiveManager } from '@visulima/interactive-manager';
+import { D as DefaultLogTypes, L as LiteralUnion$1, b as LoggerTypesConfig, R as ReadonlyMeta, f as LoggerTypesAwareReporter, E as ExtendedRfc5424LogLevels, I as InteractiveStreamReporter } from "../../packem_shared/types.d-ByY2ZuYG.js";
+import '@visulima/colorize';
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const petWithoutAutocomplete: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const petWithAutoComplete: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface Options {
+  breakLength: number;
+  customInspect: boolean;
+  depth: number;
+  indent: number | "	" | undefined;
+  maxArrayLength: number;
+  numericSeparator: boolean;
+  quoteStyle: "double" | "single";
+  showHidden: boolean;
+  showProxy: boolean;
+  stylize: (value: string, styleType: LiteralUnion<"bigint" | "boolean" | "date" | "null" | "number" | "regexp" | "special" | "string" | "symbol" | "undefined", string>) => string;
+  truncate: number;
+}
+/**
+* Abstract Pretty Reporter.
+*
+* Base class for pretty-printing reporters that format log messages with colors,
+* styles, and structured layout. Provides common functionality for styling options
+* and logger type configuration.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* class CustomPrettyReporter extends AbstractPrettyReporter {
+*   public log(meta: ReadonlyMeta) {
+*     const formatted = this.formatMessage(meta);
+*     console.log(formatted);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
+  /** Styling options for pretty formatting */
+  protected readonly styles: PrettyStyleOptions;
+  /** Logger type configurations for styling */
+  protected loggerTypes: LoggerTypesConfig<LiteralUnion$1<DefaultLogTypes, T>, L>;
+  /**
+  * Creates a new AbstractPrettyReporter instance.
+  * @param options Styling options for pretty formatting
+  * @protected
+  */
+  protected constructor(options: Partial<PrettyStyleOptions>);
+  /**
+  * Sets the logger types configuration for styling.
+  * @param types Logger type configurations with colors and labels
+  */
+  setLoggerTypes(types: LoggerTypesConfig<LiteralUnion$1<DefaultLogTypes, T>, L>): void;
+  /**
+  * Logs a message with pretty formatting.
+  * @param meta The log metadata to format and output
+  * @abstract
+  */
+  abstract log(meta: ReadonlyMeta<L>): void;
+}
+/**
+* Options for configuring pretty reporter styling.
+*/
+type PrettyStyleOptions = {
+  /** Bold styling options */
+  bold: {
+    /** Whether to bold the label text */
+    label: boolean;
+  };
+  /** Function to format dates in log output */
+  dateFormatter: (date: Date) => string;
+  /** Maximum length of message before line break (optional) */
+  messageLength: number | undefined;
+  /** Underline styling options */
+  underline: {
+    /** Whether to underline the label */
+    label: boolean;
+    /** Whether to underline prefixes */
+    prefix: boolean;
+    /** Whether to underline suffixes */
+    suffix: boolean;
+  };
+  /** Uppercase styling options */
+  uppercase: {
+    /** Whether to uppercase the label text */
+    label: boolean;
+  };
+};
+/**
+* Options for configuring the Server Pretty Reporter.
+*/
+type PrettyReporterOptions = PrettyStyleOptions & {
+  /** Error rendering options */
+  error: Partial<Omit<RenderErrorOptions, "color" | "prefix" | "indentation">>;
+  /** Object inspection options */
+  inspect: Partial<Options>;
+};
+/**
+* Server Pretty Reporter.
+*
+* A comprehensive pretty-printing reporter for Node.js server environments that
+* formats log messages with colors, structured layout, and advanced features like
+* error rendering, object inspection, and interactive terminal support.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+*
+* const logger = createPail({
+*   reporters: [new PrettyReporter({
+*     bold: { label: true },
+*     error: { color: { title: 'red' } }
+*   })]
+* });
+*
+* logger.info("Server started on port 3000");
+* logger.error("Database error", dbError);
+* ```
+*/
+declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
+  #private;
+  /**
+  * Creates a new Server Pretty Reporter instance.
+  * @param options Configuration options for styling, error rendering, and object inspection
+  */
+  constructor(options?: Partial<PrettyReporterOptions>);
+  /**
+  * Sets the stdout stream for the reporter.
+  * @param stdout_ The writable stream to use for standard output
+  */
+  setStdout(stdout_: NodeJS.WriteStream): void;
+  /**
+  * Sets the stderr stream for the reporter.
+  * @param stderr_ The writable stream to use for error output
+  */
+  setStderr(stderr_: NodeJS.WriteStream): void;
+  /**
+  * Sets the interactive manager for handling interactive output.
+  * @param manager The interactive manager instance, or undefined to disable
+  */
+  setInteractiveManager(manager?: InteractiveManager): void;
+  /**
+  * Enables or disables interactive mode.
+  * @param interactive Whether to enable interactive terminal features
+  */
+  setIsInteractive(interactive: boolean): void;
+  log(meta: ReadonlyMeta<L>): void;
+  protected _formatMessage(data: ReadonlyMeta<L>): string;
+  protected _log(message: string, logLevel: LiteralUnion$1<ExtendedRfc5424LogLevels, L>): void;
+}
+export { PrettyReporter, type PrettyReporterOptions };

package/dist/reporter/pretty/index.js

@@ -1 +1 @@
-export { PrettyReporter } from '../../packem_shared/PrettyReporter-BCvyNzXO.js';
+import{PrettyReporter as t}from"../../packem_shared/PrettyReporter-CgXnwIip.js";export{t as PrettyReporter};

package/dist/reporter/simple/simple-reporter.server.d.ts

@@ -1,20 +1,170 @@
-import type { RenderErrorOptions } from "@visulima/error";
-import type { Options as InspectorOptions } from "@visulima/inspector";
-import type { InteractiveManager } from "@visulima/interactive-manager";
-import type { InteractiveStreamReporter, ReadonlyMeta } from "../../types.d.ts";
-import type { PrettyStyleOptions } from "../pretty/abstract-pretty-reporter.d.ts";
-import { AbstractPrettyReporter } from "../pretty/abstract-pretty-reporter.d.ts";
-export type SimpleReporterOptions = PrettyStyleOptions & {
-    error: Partial<Omit<RenderErrorOptions, "color | prefix | indentation">>;
-    inspect: Partial<InspectorOptions>;
+import { InteractiveManager } from '@visulima/interactive-manager';
+import { D as DefaultLogTypes, L as LiteralUnion$1, a as LoggerTypesConfig, g as ReadonlyMeta, e as LoggerTypesAwareReporter, I as InteractiveStreamReporter } from "../../packem_shared/types.d-CM5ie2qm.js";
+import '@visulima/colorize';
+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;
 };
-export declare class SimpleReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
-    #private;
-    constructor(options?: Partial<SimpleReporterOptions>);
-    setStdout(stdout_: NodeJS.WriteStream): void;
-    setStderr(stderr_: NodeJS.WriteStream): void;
-    setInteractiveManager(manager?: InteractiveManager): void;
-    setIsInteractive(interactive: boolean): void;
-    log(meta: ReadonlyMeta<L>): void;
-    protected formatMessage(data: ReadonlyMeta<L>): string;
+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;
+};
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const petWithoutAutocomplete: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const petWithAutoComplete: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface Options {
+  breakLength: number;
+  customInspect: boolean;
+  depth: number;
+  indent: number | "	" | undefined;
+  maxArrayLength: number;
+  numericSeparator: boolean;
+  quoteStyle: "double" | "single";
+  showHidden: boolean;
+  showProxy: boolean;
+  stylize: (value: string, styleType: LiteralUnion<"bigint" | "boolean" | "date" | "null" | "number" | "regexp" | "special" | "string" | "symbol" | "undefined", string>) => string;
+  truncate: number;
+}
+/**
+* Abstract Pretty Reporter.
+*
+* Base class for pretty-printing reporters that format log messages with colors,
+* styles, and structured layout. Provides common functionality for styling options
+* and logger type configuration.
+* @template T - Custom logger type names
+* @template L - Log level types
+* @example
+* ```typescript
+* class CustomPrettyReporter extends AbstractPrettyReporter {
+*   public log(meta: ReadonlyMeta) {
+*     const formatted = this.formatMessage(meta);
+*     console.log(formatted);
+*   }
+* }
+* ```
+*/
+declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
+  /** Styling options for pretty formatting */
+  protected readonly styles: PrettyStyleOptions;
+  /** Logger type configurations for styling */
+  protected loggerTypes: LoggerTypesConfig<LiteralUnion$1<DefaultLogTypes, T>, L>;
+  /**
+  * Creates a new AbstractPrettyReporter instance.
+  * @param options Styling options for pretty formatting
+  * @protected
+  */
+  protected constructor(options: Partial<PrettyStyleOptions>);
+  /**
+  * Sets the logger types configuration for styling.
+  * @param types Logger type configurations with colors and labels
+  */
+  setLoggerTypes(types: LoggerTypesConfig<LiteralUnion$1<DefaultLogTypes, T>, L>): void;
+  /**
+  * Logs a message with pretty formatting.
+  * @param meta The log metadata to format and output
+  * @abstract
+  */
+  abstract log(meta: ReadonlyMeta<L>): void;
+}
+/**
+* Options for configuring pretty reporter styling.
+*/
+type PrettyStyleOptions = {
+  /** Bold styling options */
+  bold: {
+    /** Whether to bold the label text */
+    label: boolean;
+  };
+  /** Function to format dates in log output */
+  dateFormatter: (date: Date) => string;
+  /** Maximum length of message before line break (optional) */
+  messageLength: number | undefined;
+  /** Underline styling options */
+  underline: {
+    /** Whether to underline the label */
+    label: boolean;
+    /** Whether to underline prefixes */
+    prefix: boolean;
+    /** Whether to underline suffixes */
+    suffix: boolean;
+  };
+  /** Uppercase styling options */
+  uppercase: {
+    /** Whether to uppercase the label text */
+    label: boolean;
+  };
+};
+type SimpleReporterOptions = PrettyStyleOptions & {
+  error: Partial<Omit<Options$1, "color | prefix | indentation">>;
+  inspect: Partial<Options>;
+};
+declare class SimpleReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
+  #private;
+  constructor(options?: Partial<SimpleReporterOptions>);
+  setStdout(stdout_: NodeJS.WriteStream): void;
+  setStderr(stderr_: NodeJS.WriteStream): void;
+  setInteractiveManager(manager?: InteractiveManager): void;
+  setIsInteractive(interactive: boolean): void;
+  log(meta: ReadonlyMeta<L>): void;
+  protected formatMessage(data: ReadonlyMeta<L>): string;
 }
+export { SimpleReporter, SimpleReporterOptions };