voltlog-io 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,707 @@
+/**
+ * @module voltlog-io
+ * @description Type definitions for the OCPP-aware structured logger.
+ */
+declare const LogLevel: {
+    readonly TRACE: 10;
+    readonly DEBUG: 20;
+    readonly INFO: 30;
+    readonly WARN: 40;
+    readonly ERROR: 50;
+    readonly FATAL: 60;
+    readonly SILENT: number;
+};
+type LogLevelName = keyof typeof LogLevel;
+/** Numeric log level value */
+type LogLevelValue = (typeof LogLevel)[LogLevelName];
+/** Map from level name (lowercase) to numeric value */
+declare const LogLevelNameMap: Record<string, number>;
+/** Map from numeric value to level name */
+declare const LogLevelValueMap: Record<number, LogLevelName>;
+interface LogEntry<TMeta = Record<string, unknown>> {
+    /** Unique log ID (cuid2) */
+    id: string;
+    /** Numeric log level */
+    level: number;
+    /** Human-readable level name */
+    levelName: LogLevelName;
+    /** Log message */
+    message: string;
+    /** Unix epoch timestamp (ms) */
+    timestamp: number;
+    /** User-defined structured metadata (type-safe via generics) */
+    meta: TMeta;
+    /** Bound context from child logger (e.g. chargePointId, sessionId) */
+    context?: Record<string, unknown>;
+    /** Correlation ID for tracing across async operations */
+    correlationId?: string;
+    /** Error information */
+    error?: LogError;
+}
+interface LogError {
+    message: string;
+    stack?: string;
+    code?: string;
+    name?: string;
+}
+interface OcppExchangeMeta {
+    /** Charge point / station identity */
+    chargePointId?: string;
+    /** OCPP message type */
+    messageType?: "CALL" | "CALLRESULT" | "CALLERROR";
+    /** OCPP action name (e.g. BootNotification) */
+    action?: string;
+    /** Message direction */
+    direction?: "IN" | "OUT";
+    /** Correlation ID for request/response matching */
+    correlationId?: string;
+    /** Negotiated OCPP protocol version */
+    protocol?: string;
+    /** Serialized payload size in bytes */
+    payloadSize?: number;
+    /** Latency in milliseconds */
+    latencyMs?: number;
+    /** Response status (e.g. Accepted, Rejected) */
+    status?: string;
+}
+/**
+ * A Transformer receives formatted log entries and delivers them
+ * to a destination (console, file, webhook, database, etc.).
+ *
+ * Transformers are async-safe — `transform()` can return a Promise.
+ */
+interface Transformer<TMeta = Record<string, unknown>> {
+    /** Unique name for this transformer */
+    name: string;
+    /** Optional per-transformer level filter */
+    level?: LogLevelName;
+    /** Process a log entry */
+    transform(entry: LogEntry<TMeta>): void | Promise<void>;
+    /** Flush any buffered entries */
+    flush?(): void | Promise<void>;
+    /** Graceful shutdown */
+    close?(): void | Promise<void>;
+}
+/**
+ * Middleware intercepts log entries before they reach transformers.
+ * Used for redaction, sampling, enrichment, alerting, etc.
+ *
+ * Call `next(entry)` to continue the pipeline.
+ * Omit `next()` to drop the entry (e.g. sampling).
+ */
+type LogMiddleware<TMeta = Record<string, unknown>> = (entry: LogEntry<TMeta>, next: (entry: LogEntry<TMeta>) => void) => void;
+/**
+ * Alert rules evaluate log entries and fire callbacks
+ * when configurable conditions are met.
+ */
+interface AlertRule<TMeta = Record<string, unknown>> {
+    /** Alert name (for identification) */
+    name: string;
+    /** Condition — return true if this entry should count toward the alert */
+    when: (entry: LogEntry<TMeta>) => boolean;
+    /** Number of matching entries required to fire (default: 1) */
+    threshold?: number;
+    /** Time window in ms for threshold counting */
+    windowMs?: number;
+    /** Minimum cooldown in ms between alert firings (default: 0) */
+    cooldownMs?: number;
+    /** Callback fired when alert conditions are met */
+    onAlert: (entries: LogEntry<TMeta>[]) => void | Promise<void>;
+}
+interface LoggerOptions<TMeta = Record<string, unknown>> {
+    /** Minimum log level (default: INFO) */
+    level?: LogLevelName;
+    /** Transformers for log output */
+    transports?: Transformer<TMeta>[];
+    /** Middleware pipeline */
+    middleware?: LogMiddleware<TMeta>[];
+    /** Alert rules */
+    alerts?: AlertRule<TMeta>[];
+    /** Default bound context for all log entries */
+    context?: Record<string, unknown>;
+    /** Field paths to auto-redact (e.g. ['idToken', 'password']) */
+    redact?: string[];
+    /**
+     * When to include error stack traces:
+     * - `true` — always include
+     * - `false` — never include
+     * - `LogLevelName` — include at this level and above
+     * Default: 'ERROR'
+     */
+    includeStack?: boolean | LogLevelName;
+    /**
+     * Exchange log mode:
+     * - `true` — exchange logs alongside normal logs
+     * - `'only'` — only exchange-formatted logs
+     * - `false` — disabled (default)
+     */
+    exchangeLog?: boolean | "only";
+    /** Custom timestamp function (default: Date.now) */
+    timestamp?: () => number;
+}
+interface Logger<TMeta = Record<string, unknown>> {
+    trace(message: string, meta?: Partial<TMeta>): void;
+    debug(message: string, meta?: Partial<TMeta>): void;
+    info(message: string, meta?: Partial<TMeta>): void;
+    warn(message: string, meta?: Partial<TMeta>): void;
+    error(message: string, metaOrError?: Partial<TMeta> | Error, error?: Error): void;
+    fatal(message: string, metaOrError?: Partial<TMeta> | Error, error?: Error): void;
+    /** Create a child logger with additional bound context */
+    child(context: Record<string, unknown>): Logger<TMeta>;
+    /** Add a transformer at runtime */
+    addTransformer(transformer: Transformer<TMeta>): void;
+    /** Remove a transformer by name */
+    removeTransformer(name: string): void;
+    /** Add middleware at runtime */
+    addMiddleware(middleware: LogMiddleware<TMeta>): void;
+    /** Flush all transformers */
+    flush(): Promise<void>;
+    /** Close all transformers gracefully */
+    close(): Promise<void>;
+}
+
+/**
+ * @module voltlog-io
+ * @description Core Logger class — zero external dependencies (only cuid2), runtime-agnostic.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createLogger, consoleTransport } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   level: 'INFO',
+ *   transports: [consoleTransport()],
+ * });
+ *
+ * logger.info('Server started', { port: 9000 });
+ * ```
+ *
+ * @example Child logger with bound context
+ * ```ts
+ * const cpLogger = logger.child({ chargePointId: 'CP-101' });
+ * cpLogger.info('BootNotification received');
+ * // → auto-includes context: { chargePointId: 'CP-101' }
+ * ```
+ *
+ * @example Error with stack trace
+ * ```ts
+ * logger.error('Connection failed', new Error('ETIMEDOUT'));
+ * logger.error('Handler crashed', { action: 'BootNotification' }, new Error('null ref'));
+ * ```
+ *
+ * @example With ocpp-ws-io (if user has both packages)
+ * ```ts
+ * import { createLogger } from 'ocpp-ws-io/logger'; // re-export
+ * ```
+ */
+
+/**
+ * Create a new logger instance.
+ *
+ * @example Minimal
+ * ```ts
+ * const logger = createLogger();
+ * logger.info('Hello');
+ * ```
+ *
+ * @example Full options
+ * ```ts
+ * import { createLogger, consoleTransport, prettyTransport } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   level: 'DEBUG',
+ *   transports: [prettyTransport()],
+ *   redact: ['password', 'idToken'],
+ *   includeStack: 'ERROR',
+ * });
+ * ```
+ *
+ * @example OCPP-aware with child loggers
+ * ```ts
+ * import { createLogger, prettyTransport } from 'voltlog-io';
+ * import type { OcppExchangeMeta } from 'voltlog-io';
+ *
+ * const logger = createLogger<OcppExchangeMeta>({
+ *   level: 'INFO',
+ *   transports: [prettyTransport()],
+ * });
+ *
+ * // Per-connection child logger
+ * const cpLog = logger.child({ chargePointId: 'CP-101' });
+ * cpLog.info('OCPP message', {
+ *   messageType: 'CALL',
+ *   action: 'BootNotification',
+ *   direction: 'IN',
+ * });
+ * ```
+ */
+declare function createLogger<TMeta = Record<string, unknown>>(options?: LoggerOptions<TMeta>): Logger<TMeta>;
+
+/**
+ * @module voltlog-io
+ * @description Log level utilities — filtering, comparison, resolution.
+ */
+
+/**
+ * Resolve a level name string to its numeric value.
+ * Case-insensitive. Returns INFO if unrecognized.
+ */
+declare function resolveLevel(level: string | LogLevelName): number;
+/**
+ * Check if a log entry at `entryLevel` passes the `filterLevel`.
+ */
+declare function shouldLog(entryLevel: number, filterLevel: number): boolean;
+/**
+ * Determine whether to include stack trace for a given entry level.
+ */
+declare function shouldIncludeStack(entryLevel: number, includeStack: boolean | LogLevelName): boolean;
+
+/**
+ * @module voltlog-io
+ * @description Redaction middleware — auto-redacts sensitive fields from log meta and context.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, consoleTransport, redactionMiddleware } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [consoleTransport()],
+ *   middleware: [redactionMiddleware({ paths: ['password', 'idToken', 'authorization'] })],
+ * });
+ *
+ * logger.info('Auth attempt', { password: 's3cret', user: 'admin' });
+ * // → { password: '[REDACTED]', user: 'admin' }
+ * ```
+ */
+
+interface RedactionOptions {
+    /** Field paths to redact (case-insensitive matching) */
+    paths: string[];
+    /** Replacement value (default: '[REDACTED]') */
+    replacement?: string;
+    /** Also redact matching keys in nested objects (default: true) */
+    deep?: boolean;
+}
+/**
+ * Create a redaction middleware that replaces sensitive field values.
+ */
+declare function redactionMiddleware<TMeta = Record<string, unknown>>(options: RedactionOptions): LogMiddleware<TMeta>;
+
+/**
+ * @module voltlog-io
+ * @description Sampling middleware — rate-limits logs per key to avoid flooding.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, consoleTransport, samplingMiddleware } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [consoleTransport()],
+ *   middleware: [
+ *     samplingMiddleware({
+ *       keyFn: (entry) => `${entry.meta.action}:${entry.meta.chargePointId}`,
+ *       maxPerWindow: 10,
+ *       windowMs: 60_000, // 10 logs per minute per action+CP combo
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+
+interface SamplingOptions<TMeta = Record<string, unknown>> {
+    /**
+     * Function to extract a sampling key from a log entry.
+     * Entries with the same key share a rate limit.
+     * Default: uses `entry.message`
+     */
+    keyFn?: (entry: LogEntry<TMeta>) => string;
+    /** Maximum entries allowed per key per window (default: 100) */
+    maxPerWindow?: number;
+    /** Time window in ms (default: 60000 = 1 minute) */
+    windowMs?: number;
+    /** Probability to keep a log (0 to 1). Default: 1 (keep all) */
+    sampleRate?: number;
+    /** Logs at this level or higher always pass. Default: 40 (WARN) */
+    priorityLevel?: number;
+}
+/**
+ * Create a sampling middleware that drops logs exceeding the rate limit.
+ */
+declare function samplingMiddleware<TMeta = Record<string, unknown>>(options?: SamplingOptions<TMeta>): LogMiddleware<TMeta>;
+
+/**
+ * @module voltlog-io
+ * @description OCPP enrichment middleware — auto-enriches log entries with OCPP metadata.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, consoleTransport, ocppMiddleware } from 'voltlog-io';
+ * import type { OcppExchangeMeta } from 'voltlog-io';
+ *
+ * const logger = createLogger<OcppExchangeMeta>({
+ *   transports: [consoleTransport()],
+ *   middleware: [ocppMiddleware()],
+ * });
+ *
+ * // The middleware auto-computes payloadSize and adds correlationId to the entry
+ * logger.info('Message received', {
+ *   action: 'BootNotification',
+ *   messageType: 'CALL',
+ *   direction: 'IN',
+ * });
+ * ```
+ */
+
+interface OcppMiddlewareOptions {
+    /**
+     * Automatically compute payload size from meta if not set.
+     * Default: true
+     */
+    autoPayloadSize?: boolean;
+    /**
+     * Propagate correlationId from meta to entry.correlationId.
+     * Default: true
+     */
+    propagateCorrelationId?: boolean;
+}
+/**
+ * Create an OCPP enrichment middleware.
+ * Enriches log entries with computed OCPP metadata.
+ */
+declare function ocppMiddleware(options?: OcppMiddlewareOptions): LogMiddleware<OcppExchangeMeta>;
+
+/**
+ * @module voltlog-io
+ * @description Alert middleware — evaluates configurable rules and fires callbacks.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, consoleTransport, alertMiddleware } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [consoleTransport()],
+ *   middleware: [
+ *     alertMiddleware([
+ *       {
+ *         name: 'error-spike',
+ *         when: (entry) => entry.level >= 50, // ERROR+
+ *         threshold: 10,
+ *         windowMs: 60_000,
+ *         cooldownMs: 300_000,
+ *         onAlert: async (entries) => {
+ *           await sendEmail({ subject: `${entries.length} errors in 1 min` });
+ *         },
+ *       },
+ *       {
+ *         name: 'callerror-alert',
+ *         when: (entry) => entry.meta.messageType === 'CALLERROR',
+ *         threshold: 5,
+ *         windowMs: 60_000,
+ *         onAlert: (entries) => sendSlackNotification(entries),
+ *       },
+ *     ]),
+ *   ],
+ * });
+ * ```
+ */
+
+/**
+ * Create an alert middleware that evaluates rules against every log entry.
+ *
+ * Alerts are non-blocking — `onAlert` failures are silently caught
+ * to never interfere with the logging pipeline.
+ */
+declare function alertMiddleware<TMeta = Record<string, unknown>>(rules: AlertRule<TMeta>[]): LogMiddleware<TMeta>;
+
+/**
+ * Helper to create a type-safe middleware function.
+ *
+ * @example
+ * const myMiddleware = createMiddleware((entry, next) => {
+ *   entry.meta.foo = 'bar';
+ *   next(entry);
+ * });
+ */
+declare function createMiddleware<TMeta = Record<string, unknown>>(fn: LogMiddleware<TMeta>): LogMiddleware<TMeta>;
+
+/**
+ * @module voltlog-io
+ * @description Console transformer — outputs structured JSON logs to console.
+ * Works in Node.js, browsers, and all runtimes.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, consoleTransport } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [consoleTransport()],
+ * });
+ * ```
+ */
+
+interface ConsoleTransportOptions {
+    /** Per-transport level filter */
+    level?: LogLevelName;
+    /**
+     * Use appropriate console method per level (console.warn, console.error, etc.).
+     * Default: true
+     */
+    useConsoleLevels?: boolean;
+    /**
+     * Format the entry before outputting. Return any value that console.log can handle.
+     * Default: serializes to JSON string.
+     */
+    formatter?: (entry: LogEntry) => unknown;
+}
+/**
+ * Create a console transformer. Outputs structured JSON to the console.
+ */
+declare function consoleTransport(options?: ConsoleTransportOptions): Transformer;
+
+/**
+ * @module voltlog-io
+ * @description Pretty transformer — human-readable colored output with OCPP exchange formatting.
+ *
+ * @example Dev mode
+ * ```ts
+ * import { createLogger, prettyTransport } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [prettyTransport()],
+ * });
+ *
+ * logger.info('Server started', { port: 9000 });
+ * // → ℹ 2024-01-15T10:30:00.000Z  INFO  Server started  { port: 9000 }
+ * ```
+ *
+ * @example OCPP exchange logs
+ * ```ts
+ * logger.info('OCPP exchange', {
+ *   chargePointId: 'CP-101',
+ *   action: 'BootNotification',
+ *   messageType: 'CALL',
+ *   direction: 'IN',
+ *   latencyMs: 34,
+ *   status: 'Accepted',
+ * });
+ * // → ⚡ CP-101  →  BootNotification  [IN]  CALL
+ * // → ✔ Accepted  (34ms)
+ * ```
+ */
+
+interface PrettyTransportOptions {
+    /** Per-transport level filter */
+    level?: LogLevelName;
+    /** Show timestamps (default: true) */
+    timestamps?: boolean;
+    /** Use colors in output (default: true) */
+    colors?: boolean;
+}
+/**
+ * Create a pretty-print transformer for dev/debug use.
+ * Includes OCPP exchange log prettification.
+ */
+declare function prettyTransport(options?: PrettyTransportOptions): Transformer;
+
+/**
+ * @module voltlog-io
+ * @description JSON stream transformer — writes newline-delimited JSON to any writable stream.
+ * Useful for file logging, piping to external tools, etc.
+ *
+ * @example Write to file
+ * ```ts
+ * import { createWriteStream } from 'node:fs';
+ * import { createLogger, jsonStreamTransport } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [
+ *     jsonStreamTransport({ stream: createWriteStream('./app.log', { flags: 'a' }) }),
+ *   ],
+ * });
+ * ```
+ *
+ * @example Write to stdout
+ * ```ts
+ * const logger = createLogger({
+ *   transports: [jsonStreamTransport({ stream: process.stdout })],
+ * });
+ * ```
+ */
+
+interface JsonStreamTransportOptions {
+    /** Writable stream to output to (e.g. fs.createWriteStream, process.stdout) */
+    stream: NodeJS.WritableStream;
+    /** Per-transport level filter */
+    level?: LogLevelName;
+    /**
+     * Custom serializer. Return the string to write.
+     * Default: JSON.stringify(entry) + '\n'
+     */
+    serializer?: (entry: LogEntry) => string;
+}
+/**
+ * Create a JSON stream transformer that writes newline-delimited JSON.
+ */
+declare function jsonStreamTransport(options: JsonStreamTransportOptions): Transformer;
+
+/**
+ * @module voltlog-io
+ * @description Webhook transformer — sends log entries to external HTTP endpoints.
+ * Supports batching for performance.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, webhookTransport } from 'voltlog-io';
+ *
+ * const logger = createLogger({
+ *   transports: [
+ *     webhookTransport({
+ *       url: 'https://my-api.com/logs',
+ *       headers: { Authorization: 'Bearer token123' },
+ *       batchSize: 50,
+ *       flushIntervalMs: 5000,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+
+interface WebhookTransportOptions {
+    /** Target URL to POST log entries to */
+    url: string;
+    /** HTTP method (default: POST) */
+    method?: string;
+    /** Additional HTTP headers */
+    headers?: Record<string, string>;
+    /** Number of entries to batch before sending (default: 1 = no batching) */
+    batchSize?: number;
+    /** Max time in ms to wait before flushing a partial batch (default: 5000) */
+    flushIntervalMs?: number;
+    /** Per-transport level filter */
+    level?: LogLevelName;
+    /** Custom body serializer. Default: JSON.stringify({ entries: [...] }) */
+    serializer?: (entries: LogEntry[]) => string;
+    /** Retry failed requests (default: false) */
+    retry?: boolean;
+    /** Max retries (default: 3) */
+    maxRetries?: number;
+}
+/**
+ * Create a webhook transformer that POSTs log entries to an HTTP endpoint.
+ */
+declare function webhookTransport(options: WebhookTransportOptions): Transformer;
+
+/**
+ * @module voltlog-io
+ * @description Batch wrapper — wraps any transformer with buffering and periodic flushing.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, batchTransport, consoleTransport } from 'voltlog-io';
+ *
+ * // Batch console output: flush every 100 entries or every 2 seconds
+ * const logger = createLogger({
+ *   transports: [
+ *     batchTransport(consoleTransport(), { batchSize: 100, flushIntervalMs: 2000 }),
+ *   ],
+ * });
+ * ```
+ */
+
+interface BatchTransportOptions {
+    /** Number of entries to buffer before flushing (default: 100) */
+    batchSize?: number;
+    /** Max time in ms to wait before flushing a partial batch (default: 5000) */
+    flushIntervalMs?: number;
+}
+/**
+ * Wrap any transformer with batching. Entries are buffered and flushed
+ * either when the batch is full or the timer fires.
+ */
+declare function batchTransport(inner: Transformer, options?: BatchTransportOptions): Transformer;
+
+/**
+ * @module voltlog-io
+ * @description Redis Streams transformer — publishes log entries to a Redis Stream.
+ * Users can then subscribe (XREAD/XREADGROUP) for real-time dashboards, monitoring, etc.
+ *
+ * Requires `ioredis` — user brings their own client instance (no hard dep).
+ *
+ * @example Basic
+ * ```ts
+ * import Redis from 'ioredis';
+ * import { createLogger, redisTransport } from 'voltlog-io';
+ *
+ * const redis = new Redis();
+ * const logger = createLogger({
+ *   transports: [
+ *     redisTransport({ client: redis, streamKey: 'logs:ocpp' }),
+ *   ],
+ * });
+ *
+ * logger.info('CP connected', { chargePointId: 'CP-101' });
+ * // → XADD logs:ocpp * level INFO message "CP connected" ...
+ * ```
+ *
+ * @example With TTL and max stream length
+ * ```ts
+ * redisTransport({
+ *   client: redis,
+ *   streamKey: 'logs:ocpp',
+ *   maxLen: 10_000,        // keep last 10k entries (approximate trim)
+ * })
+ * ```
+ *
+ * @example Subscribing (consumer side)
+ * ```ts
+ * // In your dashboard / monitoring service:
+ * const redis = new Redis();
+ *
+ * // Read new entries from the stream
+ * const entries = await redis.xread('BLOCK', 0, 'STREAMS', 'logs:ocpp', '$');
+ *
+ * // Or use consumer groups for at-least-once delivery:
+ * await redis.xgroup('CREATE', 'logs:ocpp', 'dashboard', '$', 'MKSTREAM');
+ * const entries = await redis.xreadgroup(
+ *   'GROUP', 'dashboard', 'worker-1',
+ *   'BLOCK', 0, 'STREAMS', 'logs:ocpp', '>'
+ * );
+ * ```
+ */
+
+/**
+ * Minimal interface for the Redis client methods we need.
+ * Compatible with `ioredis` — user provides their own instance.
+ */
+interface RedisClient {
+    xadd(...args: (string | number)[]): Promise<string | null>;
+    quit?(): Promise<void>;
+}
+interface RedisTransportOptions {
+    /** Redis client instance (e.g. `new Redis()` from ioredis) */
+    client: RedisClient;
+    /** Redis Stream key to publish to (default: 'logs') */
+    streamKey?: string;
+    /**
+     * Max approximate stream length — older entries are trimmed.
+     * Uses MAXLEN ~ (approximate) to keep the stream bounded.
+     * Default: no limit.
+     */
+    maxLen?: number;
+    /** Per-transport level filter */
+    level?: LogLevelName;
+    /**
+     * Custom field mapper — convert LogEntry to flat key-value pairs for Redis.
+     * Default: serializes the entire entry as JSON under a single 'data' field.
+     */
+    fieldMapper?: (entry: LogEntry) => Record<string, string>;
+}
+/**
+ * Create a Redis Streams transformer.
+ *
+ * Publishes each log entry via XADD to a Redis Stream.
+ * Fire-and-forget — errors are silently swallowed to avoid blocking.
+ */
+declare function redisTransport(options: RedisTransportOptions): Transformer;
+
+export { type AlertRule, type BatchTransportOptions, type ConsoleTransportOptions, type JsonStreamTransportOptions, type LogEntry, type LogError, LogLevel, type LogLevelName, LogLevelNameMap, type LogLevelValue, LogLevelValueMap, type LogMiddleware, type Logger, type LoggerOptions, type OcppExchangeMeta, type OcppMiddlewareOptions, type PrettyTransportOptions, type RedactionOptions, type RedisClient, type RedisTransportOptions, type SamplingOptions, type Transformer, type WebhookTransportOptions, alertMiddleware, batchTransport, consoleTransport, createLogger, createMiddleware, jsonStreamTransport, ocppMiddleware, prettyTransport, redactionMiddleware, redisTransport, resolveLevel, samplingMiddleware, shouldIncludeStack, shouldLog, webhookTransport };