@visulima/pail 3.2.0 → 3.2.2

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

@@ -1,27 +1,96 @@
-import { LiteralUnion } from 'type-fest';
-import { f as StringifyAwareReporter, E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-D3ycu8-x.js';
-import { a as AbstractJsonReporterOptions, A as AbstractJsonReporter } from '../../packem_shared/abstract-json-reporter-DiyVyU0j.js';
-import '@visulima/colorize';
-import '../../interactive/index.js';
-import '../../packem_shared/index.d-oxZvg_y7.js';
-
-type AbstractHttpReporterOptions = AbstractJsonReporterOptions & {
+import type { LiteralUnion } from "type-fest";
+import type { ExtendedRfc5424LogLevels, StringifyAwareReporter } from "../../types.d.ts";
+import type { AbstractJsonReporterOptions } from "../json/abstract-json-reporter.d.ts";
+import { AbstractJsonReporter } from "../json/abstract-json-reporter.d.ts";
+/**
+ * Configuration options for the HTTP reporter.
+ */
+export type AbstractHttpReporterOptions = AbstractJsonReporterOptions & {
+    /**
+     * Content type for batch log requests. User-specified headers take precedence.
+     * @default "application/json"
+     */
     batchContentType?: string;
+    /**
+     * Field name to wrap batch entries in when batchMode is "field" (e.g., "batch" for Logflare)
+     * @default undefined
+     */
     batchFieldName?: string;
+    /**
+     * Batch mode for sending multiple log entries
+     * - "delimiter": Join entries with a delimiter (default)
+     * - "field": Wrap entries in an object with a field name
+     * - "array": Send entries as a plain JSON array
+     * @default "delimiter"
+     */
     batchMode?: "delimiter" | "field" | "array";
+    /**
+     * Delimiter to use between log entries in batch mode
+     * @default "\n"
+     */
     batchSendDelimiter?: string;
+    /**
+     * Timeout in milliseconds for sending batches regardless of size
+     * @default 5000
+     */
     batchSendTimeout?: number;
+    /**
+     * Number of log entries to batch before sending
+     * @default 100
+     */
     batchSize?: number;
+    /**
+     * Whether to use gzip compression
+     * @default false
+     */
     compression?: boolean;
+    /**
+     * Content type for single log requests. User-specified headers take precedence.
+     * @default "application/json"
+     */
     contentType?: string;
+    /**
+     * Whether to enable Edge Runtime compatibility mode
+     * When enabled, TextEncoder and compression are disabled
+     * @default false
+     */
     edgeCompat?: boolean;
+    /**
+     * Whether to enable batch sending
+     * @default true
+     */
     enableBatchSend?: boolean;
+    /**
+     * Headers to include in the request. Can be an object or a function that returns headers.
+     */
     headers?: Record<string, string> | (() => Record<string, string>);
+    /**
+     * Maximum size of a single log entry in bytes
+     * @default 1048576 (1MB)
+     */
     maxLogSize?: number;
+    /**
+     * Maximum size of the payload (uncompressed) in bytes
+     * @default 5242880 (5MB)
+     */
     maxPayloadSize?: number;
+    /**
+     * Number of retry attempts before giving up
+     * @default 3
+     */
     maxRetries?: number;
+    /**
+     * HTTP method to use for requests
+     * @default "POST"
+     */
     method?: string;
+    /**
+     * Optional callback for debugging log entries before they are sent
+     */
     onDebug?: (entry: Record<string, unknown>) => void;
+    /**
+     * Optional callback for debugging HTTP requests and responses
+     */
     onDebugRequestResponse?: (requestResponse: {
         req: {
             body: string | Uint8Array;
@@ -36,17 +105,42 @@ type AbstractHttpReporterOptions = AbstractJsonReporterOptions & {
             statusText: string;
         };
     }) => void;
+    /**
+     * Optional callback for error handling
+     */
     onError?: (error: Error) => void;
+    /**
+     * Function to transform log data into the payload format.
+     * By default, uses the JSON stringified log entry.
+     */
     payloadTemplate?: (data: {
         data?: Record<string, unknown>;
         logLevel: string;
         message: string;
     }) => string;
+    /**
+     * Whether to respect rate limiting by waiting when a 429 response is received
+     * @default true
+     */
     respectRateLimit?: boolean;
+    /**
+     * Base delay between retries in milliseconds
+     * @default 1000
+     */
     retryDelay?: number;
+    /**
+     * The URL to send logs to
+     */
     url: string;
 };
-declare abstract class AbstractHttpReporter<L extends string = string> extends AbstractJsonReporter<L> implements StringifyAwareReporter<L> {
+/**
+ * Abstract HTTP Reporter.
+ *
+ * Base class for HTTP-based reporters that sends logs to HTTP endpoints.
+ * Supports batching, compression, retries, and rate limiting.
+ * @template L - The log level type
+ */
+export declare abstract class AbstractHttpReporter<L extends string = string> extends AbstractJsonReporter<L> implements StringifyAwareReporter<L> {
     protected url: string;
     protected method: string;
     protected headers: Record<string, string> | (() => Record<string, string>);
@@ -90,13 +184,32 @@ declare abstract class AbstractHttpReporter<L extends string = string> extends A
     protected batchTimeout?: ReturnType<typeof setTimeout>;
     protected isProcessingBatch: boolean;
     protected currentBatchSize: number;
+    /**
+     * Creates a new instance of AbstractHttpReporter.
+     * @param config Configuration options for the reporter
+     */
     constructor(config: AbstractHttpReporterOptions);
+    /**
+     * Processes and ships log entries to the HTTP endpoint.
+     * @param message The JSON-formatted log message
+     * @param logLevel The log level of the message
+     * @protected
+     */
     protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+    /**
+     * Adds a payload to the batch queue and triggers sending if conditions are met.
+     */
     protected addToBatch(payload: string, logEntrySize: number): void;
+    /**
+     * Processes the current batch and sends it to the HTTP endpoint.
+     */
     protected processBatch(): Promise<void>;
+    /**
+     * Sends a batch of payloads to the HTTP endpoint.
+     */
     protected sendBatch(batch: string[]): Promise<void>;
+    /**
+     * Sends a single payload to the HTTP endpoint.
+     */
     protected sendPayload(payload: string, contentType?: string): Promise<void>;
 }
-
-export { AbstractHttpReporter };
-export type { AbstractHttpReporterOptions };

package/dist/reporter/http/http-reporter.d.ts

@@ -1,13 +1,39 @@
-import { AbstractHttpReporter, AbstractHttpReporterOptions } from './abstract-http-reporter.js';
-import 'type-fest';
-import '../../packem_shared/types-D3ycu8-x.js';
-import '@visulima/colorize';
-import '../../interactive/index.js';
-import '../../packem_shared/abstract-json-reporter-DiyVyU0j.js';
-import '../../packem_shared/index.d-oxZvg_y7.js';
-
+import type { AbstractHttpReporterOptions } from "./abstract-http-reporter.d.ts";
+import { AbstractHttpReporter } from "./abstract-http-reporter.d.ts";
+/**
+ * HTTP Reporter.
+ *
+ * A reporter that sends logs to HTTP endpoints.
+ * Supports batching, compression, retries, and rate limiting.
+ * Works in both Node.js server and browser environments.
+ * @template L - The log level type
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ * import { HttpReporter } from "@visulima/pail/reporter/http";
+ *
+ * const logger = createPail({
+ *   reporters: [
+ *     new HttpReporter({
+ *       url: "https://api.example.com/logs",
+ *       method: "POST",
+ *       headers: {
+ *         "Authorization": "Bearer token"
+ *       },
+ *       enableBatchSend: true,
+ *       batchSize: 100
+ *     })
+ *   ]
+ * });
+ *
+ * logger.info("Application started", { version: "1.0.0" });
+ * ```
+ */
 declare class HttpReporter<L extends string = string> extends AbstractHttpReporter<L> {
+    /**
+     * Creates a new HTTP Reporter instance.
+     * @param options Configuration options for HTTP reporting
+     */
     constructor(options: AbstractHttpReporterOptions);
 }
-
-export { HttpReporter as default };
+export default HttpReporter;

package/dist/reporter/http/http-reporter.edge-light.d.ts

@@ -1,168 +1,40 @@
-import { Primitive, LiteralUnion } from 'type-fest';
-
-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 ReadonlyMeta<L extends string> = Readonly<Meta<L>>;
-interface Reporter<L extends string> {
-    log: (meta: ReadonlyMeta<L>) => void;
-}
-interface StringifyAwareReporter<L extends string> extends Reporter<L> {
-    setStringify: (stringify: typeof JSON.stringify) => void;
-}
-
-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
-}
-
-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;
-}
-
-type AbstractHttpReporterOptions = AbstractJsonReporterOptions & {
-    batchContentType?: string;
-    batchFieldName?: string;
-    batchMode?: "delimiter" | "field" | "array";
-    batchSendDelimiter?: string;
-    batchSendTimeout?: number;
-    batchSize?: number;
-    compression?: boolean;
-    contentType?: string;
-    edgeCompat?: boolean;
-    enableBatchSend?: boolean;
-    headers?: Record<string, string> | (() => Record<string, string>);
-    maxLogSize?: number;
-    maxPayloadSize?: number;
-    maxRetries?: number;
-    method?: string;
-    onDebug?: (entry: Record<string, unknown>) => void;
-    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;
-    payloadTemplate?: (data: {
-        data?: Record<string, unknown>;
-        logLevel: string;
-        message: string;
-    }) => string;
-    respectRateLimit?: boolean;
-    retryDelay?: number;
-    url: string;
-};
-declare abstract class AbstractHttpReporter<L extends string = string> extends AbstractJsonReporter<L> implements StringifyAwareReporter<L> {
-    protected url: string;
-    protected method: string;
-    protected headers: Record<string, string> | (() => Record<string, string>);
-    protected contentType: string;
-    protected batchContentType: string;
-    protected onError?: (error: Error) => void;
-    protected onDebug?: (entry: Record<string, unknown>) => void;
-    protected 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;
-    protected payloadTemplate: (data: {
-        data?: Record<string, unknown>;
-        logLevel: string;
-        message: string;
-    }) => string;
-    protected compression: boolean;
-    protected maxRetries: number;
-    protected retryDelay: number;
-    protected respectRateLimit: boolean;
-    protected enableBatchSend: boolean;
-    protected batchSize: number;
-    protected batchSendTimeout: number;
-    protected batchSendDelimiter: string;
-    protected batchMode: "delimiter" | "field" | "array";
-    protected batchFieldName?: string;
-    protected maxLogSize: number;
-    protected maxPayloadSize: number;
-    protected edgeCompat: boolean;
-    protected batchQueue: string[];
-    protected batchTimeout?: ReturnType<typeof setTimeout>;
-    protected isProcessingBatch: boolean;
-    protected currentBatchSize: number;
-    constructor(config: AbstractHttpReporterOptions);
-    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-    protected addToBatch(payload: string, logEntrySize: number): void;
-    protected processBatch(): Promise<void>;
-    protected sendBatch(batch: string[]): Promise<void>;
-    protected sendPayload(payload: string, contentType?: string): Promise<void>;
-}
-
+import type { AbstractHttpReporterOptions } from "./abstract-http-reporter.d.ts";
+import { AbstractHttpReporter } from "./abstract-http-reporter.d.ts";
+/**
+ * HTTP Reporter for Edge Runtime environments.
+ *
+ * A reporter optimized for Edge Runtime environments (Next.js Edge, Cloudflare Workers, etc.)
+ * that sends logs to HTTP endpoints. Edge compatibility mode is enabled by default.
+ * Supports batching, retries, and rate limiting. Compression is disabled for Edge compatibility.
+ * @template L - The log level type
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ * import { HttpReporterEdgeLight } from "@visulima/pail/reporter/http/edge-light";
+ *
+ * const logger = createPail({
+ *   reporters: [
+ *     new HttpReporterEdgeLight({
+ *       url: "https://api.example.com/logs",
+ *       method: "POST",
+ *       headers: {
+ *         "Authorization": "Bearer token"
+ *       },
+ *       enableBatchSend: true,
+ *       batchSize: 50
+ *     })
+ *   ]
+ * });
+ *
+ * logger.info("Edge function started");
+ * ```
+ */
 declare class HttpReporterEdgeLight<L extends string = string> extends AbstractHttpReporter<L> {
+    /**
+     * Creates a new HTTP Reporter Edge Light instance.
+     * Edge compatibility mode is automatically enabled.
+     * @param options Configuration options for HTTP reporting
+     */
     constructor(options: Omit<AbstractHttpReporterOptions, "edgeCompat">);
 }
-
-export { HttpReporterEdgeLight as default };
+export default HttpReporterEdgeLight;

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

@@ -0,0 +1,7 @@
+/**
+ * Compresses data using gzip compression.
+ * @param data The data to compress as a string
+ * @returns A Promise that resolves to the compressed data as Uint8Array
+ */
+declare const compressData: (data: string) => Promise<Uint8Array>;
+export default compressData;

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-DiyVyU0j.js';
-import { LiteralUnion } from 'type-fest';
-import { E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-D3ycu8-x.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.d.ts

@@ -1,16 +1,3 @@
-import { A as AbstractJsonReporter, a as AbstractJsonReporterOptions } from '../../packem_shared/abstract-json-reporter-DiyVyU0j.js';
-import { LiteralUnion } from 'type-fest';
-import { S as StreamAwareReporter, E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-D3ycu8-x.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,2 +1,2 @@
 export { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-intFdT_A.js';
-export { default as JsonReporter } from '../../packem_shared/JsonReporter-BqWsVkHP.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;