@visulima/pail 3.1.0 → 3.2.1

package/dist/reporter/http/utils/log-size-error.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Error thrown when a log entry exceeds the maximum allowed size.
+ */
+declare class LogSizeError extends Error {
+    /**
+     * The log entry data that caused the error
+     */
+    readonly logData: Record<string, unknown>;
+    /**
+     * The actual size of the log entry in bytes
+     */
+    readonly actualSize: number;
+    /**
+     * The maximum allowed size in bytes
+     */
+    readonly maxSize: number;
+    /**
+     * Creates a new LogSizeError instance.
+     * @param message Descriptive error message explaining the size violation
+     * @param logData The log entry data that caused the error
+     * @param actualSize Size of the log entry in bytes
+     * @param maxSize Maximum allowed size in bytes
+     * @example
+     * ```typescript
+     * throw new LogSizeError("Log too large", logData, 2000000, 1000000);
+     * ```
+     */
+    constructor(message: string, logData: Record<string, unknown>, actualSize: number, maxSize: number);
+}
+export default LogSizeError;

package/dist/reporter/http/utils/retry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Sends an HTTP request with retry logic and rate limiting support.
+ * @param url The URL to send the request to
+ * @param method The HTTP method to use
+ * @param headers Request headers
+ * @param body The request body (string or Uint8Array)
+ * @param maxRetries Maximum number of retry attempts
+ * @param retryDelay Base delay between retries in milliseconds
+ * @param respectRateLimit Whether to respect rate limiting (429 responses)
+ * @param onDebugRequestResponse Optional callback for debugging requests/responses
+ * @param onError Optional callback for error handling
+ */
+declare const sendWithRetry: (url: string, method: string, headers: Record<string, string>, body: string | Uint8Array, maxRetries: number, retryDelay: number, respectRateLimit: boolean, onDebugRequestResponse?: (requestResponse: {
+    req: {
+        body: string | Uint8Array;
+        headers: Record<string, string>;
+        method: string;
+        url: string;
+    };
+    res: {
+        body: string;
+        headers: Record<string, string>;
+        status: number;
+        statusText: string;
+    };
+}) => void, onError?: (error: Error) => void) => Promise<void>;
+export default sendWithRetry;

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

@@ -0,0 +1,61 @@
+import type { stringify } from "safe-stable-stringify";
+import type { LiteralUnion } from "type-fest";
+import type { ExtendedRfc5424LogLevels, ReadonlyMeta, StringifyAwareReporter } from "../../types.d.ts";
+/**
+ * Options for configuring JSON reporters.
+ */
+export 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);
+ *   }
+ * }
+ * ```
+ */
+export 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_: any): 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;
+}

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

@@ -1,13 +1,3 @@
-import { A as AbstractJsonReporter, a as AbstractJsonReporterOptions } from '../../packem_shared/abstract-json-reporter-CPsNkpz8.js';
-import { LiteralUnion } from 'type-fest';
-import { E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-DVzG8TWL.js';
-import '../../packem_shared/index.d-oxZvg_y7.js';
-import '@visulima/colorize';
-import '../../interactive/index.js';
-
-declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> {
-    constructor(options?: Partial<AbstractJsonReporterOptions>);
-    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-
-export { AbstractJsonReporter, AbstractJsonReporterOptions, JsonReporter };
+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";

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

@@ -1 +1,2 @@
-import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-UftN6CIL.js";import{default as p}from"../../packem_shared/JsonReporter-Dl4m0xZe.js";export{e as AbstractJsonReporter,p as JsonReporter};
+export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-intFdT_A.js';
+export { default as JsonReporter } from '../../packem_shared/JsonReporter-DcM2LBX9.js';

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

@@ -1,16 +1,3 @@
-import { A as AbstractJsonReporter, a as AbstractJsonReporterOptions } from '../../packem_shared/abstract-json-reporter-CPsNkpz8.js';
-import { LiteralUnion } from 'type-fest';
-import { S as StreamAwareReporter, E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-DVzG8TWL.js';
-import '../../packem_shared/index.d-oxZvg_y7.js';
-import '@visulima/colorize';
-import '../../interactive/index.js';
-
-declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> implements StreamAwareReporter<L> {
-    #private;
-    constructor(options?: Partial<AbstractJsonReporterOptions>);
-    setStdout(stdout_: NodeJS.WriteStream): void;
-    setStderr(stderr_: NodeJS.WriteStream): void;
-    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-
-export { AbstractJsonReporter, AbstractJsonReporterOptions, JsonReporter };
+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";

package/dist/reporter/json/index.js

@@ -1 +1,2 @@
-import{AbstractJsonReporter as e}from"../../packem_shared/AbstractJsonReporter-UftN6CIL.js";import{default as p}from"../../packem_shared/JsonReporter-DTBtHNaD.js";export{e as AbstractJsonReporter,p as JsonReporter};
+export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-intFdT_A.js';
+export { default as JsonReporter } from '../../packem_shared/JsonReporter-C0AXk99i.js';

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

@@ -0,0 +1,40 @@
+import type { LiteralUnion } from "type-fest";
+import type { ExtendedRfc5424LogLevels } from "../../types.d.ts";
+import type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
+import { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
+/**
+ * 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 _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export default JsonReporter;

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

@@ -0,0 +1,50 @@
+import type { LiteralUnion } from "type-fest";
+import type { ExtendedRfc5424LogLevels, StreamAwareReporter } from "../../types.d.ts";
+import type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
+import { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
+/**
+ * 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 _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export default JsonReporter;

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

@@ -0,0 +1,83 @@
+import type { LiteralUnion } from "type-fest";
+import type { DefaultLogTypes, LoggerTypesAwareReporter, LoggerTypesConfig, ReadonlyMeta } from "../../types.d.ts";
+/**
+ * Default date formatter for pretty reporters.
+ *
+ * Formats a Date object as HH:MM:SS (24-hour format).
+ * @param date The date to format
+ * @returns Formatted time string
+ * @example
+ * ```typescript
+ * dateFormatter(new Date()); // "14:30:25"
+ * ```
+ */
+export declare const dateFormatter: (date: Date) => string;
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+export 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.
+ */
+export 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;
+    };
+};

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

@@ -1,13 +1,2 @@
-import { A as AbstractPrettyReporter, P as PrettyStyleOptions } from '../../packem_shared/abstract-pretty-reporter-DB2G-qlI.js';
-import { f as ReadonlyMeta } from '../../packem_shared/types-DVzG8TWL.js';
-import 'type-fest';
-import '@visulima/colorize';
-import '../../interactive/index.js';
-
-declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> {
-    #private;
-    constructor(options?: Partial<PrettyStyleOptions>);
-    log(meta: ReadonlyMeta<L>): void;
-}
-
-export { PrettyReporter, PrettyStyleOptions };
+export type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
+export { default as PrettyReporter } from "./pretty-reporter.d.ts";

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

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

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

@@ -1,25 +1,2 @@
-import { O as Options$1, a as Options } from '../../packem_shared/index.d-BR1GjZri.js';
-import { LiteralUnion } from 'type-fest';
-import { InteractiveManager } from '../../interactive/index.js';
-import { I as InteractiveStreamReporter, f as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-DVzG8TWL.js';
-import { P as PrettyStyleOptions, A as AbstractPrettyReporter } from '../../packem_shared/abstract-pretty-reporter-DB2G-qlI.js';
-import '@visulima/colorize';
-
-type PrettyReporterOptions = PrettyStyleOptions & {
-    error: Partial<Omit<Options$1, "color" | "prefix" | "indentation">>;
-    inspect: Partial<Options>;
-};
-declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
-    #private;
-    constructor(options?: Partial<PrettyReporterOptions>);
-    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;
-    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-
-export { PrettyReporter };
-export type { PrettyReporterOptions };
+export type { PrettyReporterOptions } from "./pretty-reporter.d.ts";
+export { PrettyReporter } from "./pretty-reporter.d.ts";

package/dist/reporter/pretty/index.js

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

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

@@ -0,0 +1,36 @@
+import type { ReadonlyMeta } from "../../types.d.ts";
+import type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
+import { AbstractPrettyReporter } from "./abstract-pretty-reporter.d.ts";
+/**
+ * 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 default PrettyReporter;

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

@@ -0,0 +1,70 @@
+import type { RenderErrorOptions } from "@visulima/error/error";
+import type { Options as InspectorOptions } from "@visulima/inspector";
+import type { LiteralUnion } from "type-fest";
+import type InteractiveManager from "../../interactive/interactive-manager.d.ts";
+import type { ExtendedRfc5424LogLevels, InteractiveStreamReporter, ReadonlyMeta } from "../../types.d.ts";
+import type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
+import { AbstractPrettyReporter } from "./abstract-pretty-reporter.d.ts";
+/**
+ * Options for configuring the Server Pretty Reporter.
+ */
+export type PrettyReporterOptions = PrettyStyleOptions & {
+    /** Error rendering options */
+    error: Partial<Omit<RenderErrorOptions, "color" | "prefix" | "indentation">>;
+    /** Object inspection options */
+    inspect: Partial<InspectorOptions>;
+};
+/**
+ * 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);
+ * ```
+ */
+export 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;
+}

package/dist/reporter/raw/raw-reporter.browser.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyMeta, Reporter } from "../../types.d.ts";
+declare class RawReporter<L extends string = string> implements Reporter<L> {
+    log(meta: ReadonlyMeta<L>): void;
+}
+export default RawReporter;

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

@@ -0,0 +1,13 @@
+import type { Options as InspectorOptions } from "@visulima/inspector";
+import type InteractiveManager from "../../interactive/interactive-manager.d.ts";
+import type { ReadonlyMeta, StreamAwareReporter } from "../../types.d.ts";
+declare class RawReporter<L extends string = string> implements StreamAwareReporter<L> {
+    #private;
+    constructor(inspectOptions?: Partial<InspectorOptions>);
+    setStdout(stdout_: NodeJS.WriteStream): void;
+    setStderr(stderr_: NodeJS.WriteStream): void;
+    setInteractiveManager(manager?: InteractiveManager): void;
+    setIsInteractive(interactive: boolean): void;
+    log(meta: ReadonlyMeta<L>): void;
+}
+export default RawReporter;

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

@@ -1,15 +1,14 @@
-import { O as Options$1, a as Options } from '../../packem_shared/index.d-BR1GjZri.js';
-import { InteractiveManager } from '../../interactive/index.js';
-import { I as InteractiveStreamReporter, f as ReadonlyMeta } from '../../packem_shared/types-DVzG8TWL.js';
-import { P as PrettyStyleOptions, A as AbstractPrettyReporter } from '../../packem_shared/abstract-pretty-reporter-DB2G-qlI.js';
-import 'type-fest';
-import '@visulima/colorize';
-
-type SimpleReporterOptions = PrettyStyleOptions & {
-    error: Partial<Omit<Options$1, "color | prefix | indentation">>;
-    inspect: Partial<Options>;
+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>;
 };
-declare class SimpleReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
+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;
@@ -19,6 +18,3 @@ declare class SimpleReporter<T extends string = string, L extends string = strin
     log(meta: ReadonlyMeta<L>): void;
     protected formatMessage(data: ReadonlyMeta<L>): string;
 }
-
-export { SimpleReporter };
-export type { SimpleReporterOptions };