@visulima/pail 4.0.0-alpha.2 → 4.0.0-alpha.21

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

@@ -1,3 +1,98 @@
-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 { R as ReadonlyMeta, E as ExtendedRfc5424LogLevels, L as LiteralUnion, S as StringifyAwareReporter } from "../../packem_shared/types.d-xxE3FOD3.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-BaZ33PlE.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-BRw4skd5.js';
+import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-CVwjgboT.js";import{default as p}from"../../packem_shared/JsonReporter-BJFnahby.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-Boj5w068.js";
+import { E as ExtendedRfc5424LogLevels, L as LiteralUnion, S as StreamAwareReporter } from "../../packem_shared/types.d-Ck_RSjLg.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-BaZ33PlE.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-VzgyLEYz.js';
+import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-CF0KKdQS.js";import{default as p}from"../../packem_shared/JsonReporter-CnLM-d0U.js";export{e as AbstractJsonReporter,p as JsonReporter};

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

@@ -1,2 +1,105 @@
-export type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
-export { default as PrettyReporter } from "./pretty-reporter.d.ts";
+import { D as DefaultLogTypes, L as LiteralUnion, a as LoggerTypesConfig, R as ReadonlyMeta, b as LoggerTypesAwareReporter } from "../../packem_shared/types.d-xxE3FOD3.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-DySIXBjQ.js';
+import{default as t}from"../../packem_shared/PrettyReporter-D75CJT0C.js";export{t as PrettyReporter};

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

@@ -1,2 +1,183 @@
-export type { PrettyReporterOptions } from "./pretty-reporter.d.ts";
-export { PrettyReporter } from "./pretty-reporter.d.ts";
+import { L as LiteralUnion, D as DefaultLogTypes, c as LoggerTypesConfig, R as ReadonlyMeta, f as LoggerTypesAwareReporter, E as ExtendedRfc5424LogLevels, I as InteractiveStreamReporter } from "../../packem_shared/types.d-Ck_RSjLg.js";
+import { InteractiveManager } from '@visulima/interactive-manager';
+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;
+};
+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 | "	";
+  prefix: string;
+};
+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<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;
+  };
+};
+/**
+* Options for configuring the Server Pretty Reporter.
+*/
+type PrettyReporterOptions = PrettyStyleOptions & {
+  /** Error rendering options */
+  error: Partial<Omit<Options$1, "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<ExtendedRfc5424LogLevels, L>): void;
+}
+export { PrettyReporter, type PrettyReporterOptions };

package/dist/reporter/pretty/index.js

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

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

@@ -1,20 +1,135 @@
-import type { RenderErrorOptions } from "@visulima/error";
-import type { Options as InspectorOptions } from "@visulima/inspector";
-import type InteractiveManager from "../../interactive/interactive-manager.d.ts";
-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 { LiteralUnion } from 'type-fest';
+import { InteractiveManager } from '@visulima/interactive-manager';
+import { D as DefaultLogTypes, L as LoggerTypesConfig, f as ReadonlyMeta, d as LoggerTypesAwareReporter, I as InteractiveStreamReporter } from "../../packem_shared/types.d-Cz9S7jZh.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 | "	";
+  prefix: string;
+};
+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<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;
+  };
+};
+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 };