@rawnodes/logger 2.7.1 → 2.8.0

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { EventEmitter } from 'events';
 import { z } from 'zod';
 
 declare const LOG_LEVELS: {
@@ -45,6 +44,47 @@ interface HttpTransportBaseConfig {
     flushInterval?: number;
     maxRetries?: number;
     retryDelay?: number;
+    /**
+     * Maximum number of messages the in-memory queue will hold before dropping.
+     * Provides a hard upper bound on memory usage when a transport is degraded
+     * or offline — without this, a failing transport + steady log volume grows
+     * the queue until OOM. Default: unbounded.
+     *
+     * Recommended for production: `10_000` — enough to absorb transient blips,
+     * small enough to avoid runaway memory.
+     */
+    maxQueueSize?: number;
+    /**
+     * Policy applied when the queue is full.
+     * - `'drop-oldest'` (default): prefers keeping recent events — during an
+     *   outage old logs are usually stale.
+     * - `'drop-newest'`: prefers preserving historical context — useful if you
+     *   care more about the events leading up to the outage than the noise
+     *   happening during it.
+     */
+    dropPolicy?: 'drop-oldest' | 'drop-newest';
+    /**
+     * Called when messages are dropped due to queue overflow. Receives only the
+     * messages that were discarded. If not provided, drops are silent.
+     *
+     * Callback MUST NOT throw; if it does, the exception is swallowed.
+     */
+    onDrop?: (droppedMessages: unknown[]) => void;
+    /**
+     * Called when a batch fails after all retries and messages are dropped.
+     * If not provided, the error is logged to stderr.
+     *
+     * The callback MUST NOT throw; if it does, the failure is swallowed and a
+     * stderr fallback is used. This is intentional — a logger must never
+     * propagate its own transport errors back into the host application.
+     */
+    onError?: (error: Error, droppedMessages: unknown[]) => void;
+    /**
+     * Timeout in milliseconds for a single outbound HTTP request. Default:
+     * `10_000`. Applies to Discord/Telegram `fetch`. CloudWatch uses the AWS
+     * SDK's own timeout configuration.
+     */
+    requestTimeout?: number;
 }
 interface DiscordConfig extends HttpTransportBaseConfig {
     webhookUrl: string;
@@ -64,6 +104,35 @@ interface TelegramConfig extends HttpTransportBaseConfig {
     threadId?: number;
     replyToMessageId?: number;
 }
+interface ZohoCliqBotConfig {
+    /** Bot display name (shown in the channel). */
+    name: string;
+    /** Optional bot avatar URL. */
+    image?: string;
+}
+interface ZohoCliqConfig extends HttpTransportBaseConfig {
+    /**
+     * Incoming webhook URL. If provided, `companyId`/`channel`/`region` are
+     * ignored and this URL is used as-is (with `zapikey` appended as query).
+     */
+    webhookUrl?: string;
+    /** Zoho Cliq company/org ID. Required unless `webhookUrl` is set. */
+    companyId?: string;
+    /** Target channel name (the `channelsbyname` API segment). Required unless `webhookUrl` is set. */
+    channel?: string;
+    /** Zoho region/TLD: 'eu' | 'com' | 'in' | etc. Default: 'eu'. */
+    region?: string;
+    /** Zoho API key (zapikey). Required. */
+    apiKey: string;
+    /** If true (default), message is posted as a broadcast so all members are notified. */
+    broadcast?: boolean;
+    /** Post as a custom bot instead of the default user. */
+    bot?: ZohoCliqBotConfig;
+    /** Include ISO timestamp in each formatted message. Default: true. */
+    includeTimestamp?: boolean;
+    /** Include meta as a fenced code block. Default: true. */
+    includeMeta?: boolean;
+}
 type LogStreamPattern = 'hostname' | 'hostname-date' | 'hostname-uuid' | 'date' | 'uuid';
 interface LogStreamPatternConfig {
     pattern: LogStreamPattern;
@@ -73,6 +142,20 @@ interface LogStreamTemplateConfig {
     template: string;
 }
 type LogStreamName = string | LogStreamPatternConfig | LogStreamTemplateConfig;
+interface RelayConfig {
+    /** URL of the relay API (e.g., https://relay.example.com) */
+    apiUrl: string;
+    /** Authentication token for the relay server */
+    token: string;
+    /** Polling interval in ms (default: 30000) */
+    pollInterval?: number;
+    /** Ring buffer capacity - max logs held during reconnect (default: 1000) */
+    bufferSize?: number;
+    /** WebSocket reconnect base delay in ms (default: 1000) */
+    reconnectDelay?: number;
+    /** Max reconnect delay in ms (default: 30000) */
+    maxReconnectDelay?: number;
+}
 interface CloudWatchConfig extends HttpTransportBaseConfig {
     logGroupName: string;
     /** Log stream name - string, pattern config, or template config. Defaults to hostname pattern */
@@ -113,6 +196,9 @@ interface LoggerConfig {
     discord?: DiscordConfig | DiscordConfig[];
     telegram?: TelegramConfig | TelegramConfig[];
     cloudwatch?: CloudWatchConfig | CloudWatchConfig[];
+    zohoCliq?: ZohoCliqConfig | ZohoCliqConfig[];
+    /** Relay transport config — streams logs to a remote server via WebSocket (runs in worker thread) */
+    relay?: RelayConfig;
     /** Enable caller info (file:line) in logs. Pass true for defaults or CallerConfig for options */
     caller?: boolean | CallerConfig;
     /** Hostname to include in all log entries. Defaults to os.hostname() if not specified */
@@ -140,7 +226,7 @@ declare class LoggerStore<TContext extends LoggerContext = LoggerContext> {
 declare class Logger<TContext extends LoggerContext = LoggerContext> {
     private state;
     private context;
-    private profileTimers;
+    private profileTimers?;
     private constructor();
     static create<TContext extends LoggerContext = LoggerContext>(config: LoggerConfig, store?: LoggerStore<TContext>): Logger<TContext>;
     for(context: string): Logger<TContext>;
@@ -152,10 +238,29 @@ declare class Logger<TContext extends LoggerContext = LoggerContext> {
     /**
      * Gracefully shutdown the logger, flushing all pending messages.
      * Should be called before process exit to ensure no logs are lost.
+     *
+     * `timeoutMs` is forwarded to each transport's `close()` as a per-transport
+     * cap; it prevents a dead transport from blocking the whole shutdown.
+     * Default: 5000ms. Pass `Infinity` for legacy unbounded behaviour.
      */
-    shutdown(): Promise<void>;
+    shutdown(timeoutMs?: number): Promise<void>;
     profile(id: string, meta?: object): void;
-    error(errorOrMessage: Error | string, messageOrMeta?: string | Meta, meta?: Meta): void;
+    /**
+     * Log an error. Supported shapes:
+     *   error(message: string)
+     *   error(message: string, meta)
+     *   error(error: Error | unknown)
+     *   error(error: Error | unknown, message: string)
+     *   error(error: Error | unknown, meta)
+     *   error(error: Error | unknown, message: string, meta)
+     *
+     * The first argument is treated as an error value whenever it is not a string.
+     * Non-Error values (plain objects, numbers, etc. — e.g. anything caught by
+     * TypeScript's `catch (err)` clause, which is typed as `unknown`) are passed
+     * through `serializeError` so they produce a sensible `errorMessage` and, when
+     * possible, a `stack` / HTTP diagnostic payload.
+     */
+    error(errorOrMessage: Error | string | unknown, messageOrMeta?: string | Meta, meta?: Meta): void;
     warn(message: string, meta?: Meta): void;
     info(message: string, meta?: Meta): void;
     http(message: string, meta?: Meta): void;
@@ -185,6 +290,7 @@ interface BufferedMessage {
     context?: string;
     meta?: Record<string, unknown>;
 }
+type DropPolicy = 'drop-oldest' | 'drop-newest';
 interface BufferOptions {
     batchSize: number;
     flushInterval: number;
@@ -192,6 +298,25 @@ interface BufferOptions {
     retryDelay: number;
     onFlush: (messages: BufferedMessage[]) => Promise<void>;
     onError?: (error: Error, messages: BufferedMessage[]) => void;
+    /**
+     * Maximum number of messages the queue will hold before dropping. When the
+     * queue is full, behaviour follows `dropPolicy`. Default: unbounded.
+     */
+    maxQueueSize?: number;
+    /**
+     * Policy applied when the queue is at `maxQueueSize` and a new message
+     * arrives. Default: `'drop-oldest'` — prefers keeping recent events, since
+     * during an outage the old ones are usually stale anyway.
+     */
+    dropPolicy?: DropPolicy;
+    /**
+     * Called when messages are dropped due to queue overflow. Receives the
+     * messages that were discarded (not the remaining queue). If not provided,
+     * the drop is silent — consumers can still track it via buffer metrics.
+     *
+     * Callback MUST NOT throw; if it does, the exception is swallowed.
+     */
+    onDrop?: (droppedMessages: BufferedMessage[]) => void;
 }
 declare class MessageBuffer {
     private options;
@@ -199,10 +324,24 @@ declare class MessageBuffer {
     private timer;
     private flushing;
     private closed;
+    private droppedCount;
     constructor(options: BufferOptions);
     add(message: BufferedMessage): void;
     flush(): Promise<void>;
-    close(): Promise<void>;
+    /**
+     * Stops accepting new messages and attempts to flush what's already buffered.
+     * Returns when the queue is drained OR when `timeoutMs` elapses. A timeout
+     * is essential during graceful shutdown — without it, a dead transport would
+     * block process exit indefinitely, and orchestrators like Kubernetes would
+     * escalate to SIGKILL after their grace period.
+     *
+     * Default timeout: 5 seconds. Pass `Infinity` to preserve legacy behaviour.
+     */
+    close(timeoutMs?: number): Promise<void>;
+    /** Current number of messages waiting in the queue. */
+    get size(): number;
+    /** Total number of messages dropped due to queue overflow since creation. */
+    get droppedTotal(): number;
     private scheduleFlush;
     private clearTimer;
     private sendWithRetry;
@@ -214,12 +353,35 @@ interface BaseHttpTransportOptions {
     flushInterval?: number;
     maxRetries?: number;
     retryDelay?: number;
+    maxQueueSize?: number;
+    dropPolicy?: DropPolicy;
+    onDrop?: (droppedMessages: BufferedMessage[]) => void;
+    /**
+     * Called when a batch fails after all retries and messages are dropped.
+     * If not provided, the error is logged to stderr.
+     *
+     * The callback MUST NOT throw; if it does, the failure is swallowed and a
+     * stderr fallback is used. A logger must never propagate transport errors
+     * back into the host application.
+     */
+    onError?: (error: Error, droppedMessages: BufferedMessage[]) => void;
 }
-declare abstract class BaseHttpTransport extends EventEmitter {
+declare abstract class BaseHttpTransport {
     protected buffer: MessageBuffer;
+    private onErrorCallback?;
     constructor(opts?: BaseHttpTransportOptions);
     log(info: Record<string, unknown>, callback: () => void): void;
-    close(): Promise<void>;
+    /**
+     * Stop accepting new messages and flush what's buffered. `timeoutMs` caps
+     * how long the flush may take; after that the remaining queue is discarded
+     * so shutdown can complete. Default 5000ms.
+     */
+    close(timeoutMs?: number): Promise<void>;
+    /** Current buffered message count and total drops since creation. */
+    getMetrics(): {
+        queueSize: number;
+        droppedTotal: number;
+    };
     protected transformMessage(info: Record<string, unknown>): BufferedMessage;
     protected handleError(error: Error, messages: BufferedMessage[]): void;
     protected abstract sendBatch(messages: BufferedMessage[]): Promise<void>;
@@ -231,6 +393,7 @@ declare function matchesContext(storeContext: LoggerContext | undefined, loggerC
 
 declare class DiscordTransport extends BaseHttpTransport {
     private config;
+    private requestTimeout;
     constructor(config: DiscordConfig);
     protected sendBatch(messages: BufferedMessage[]): Promise<void>;
     private sendEmbedBatch;
@@ -246,6 +409,7 @@ declare class DiscordTransport extends BaseHttpTransport {
 declare class TelegramTransport extends BaseHttpTransport {
     private config;
     private apiUrl;
+    private requestTimeout;
     constructor(config: TelegramConfig);
     protected sendBatch(messages: BufferedMessage[]): Promise<void>;
     private formatBatchMessage;
@@ -275,6 +439,18 @@ declare class CloudWatchTransport extends BaseHttpTransport {
     private isInvalidSequenceTokenError;
 }
 
+declare class ZohoCliqTransport extends BaseHttpTransport {
+    private config;
+    private endpoint;
+    private requestTimeout;
+    constructor(config: ZohoCliqConfig);
+    private buildEndpoint;
+    protected sendBatch(messages: BufferedMessage[]): Promise<void>;
+    private formatMessage;
+    private splitContent;
+    private post;
+}
+
 interface TimingResult {
     label: string;
     durationMs: number;
@@ -401,6 +577,35 @@ declare const LogStreamPatternConfigSchema: z.ZodType<LogStreamPatternConfig>;
 declare const LogStreamTemplateConfigSchema: z.ZodType<LogStreamTemplateConfig>;
 declare const LogStreamNameSchema: z.ZodType<LogStreamName>;
 declare const CloudWatchConfigSchema: z.ZodType<CloudWatchConfig>;
+declare const ZohoCliqConfigSchema: z.ZodObject<{
+    level: z.ZodOptional<z.ZodType<"off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly", unknown, z.core.$ZodTypeInternals<"off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly", unknown>>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodType<LevelRule, unknown, z.core.$ZodTypeInternals<LevelRule, unknown>>>>;
+    batchSize: z.ZodOptional<z.ZodNumber>;
+    flushInterval: z.ZodOptional<z.ZodNumber>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    onError: z.ZodType<HttpTransportBaseConfig["onError"]>;
+    onDrop: z.ZodType<HttpTransportBaseConfig["onDrop"]>;
+    maxQueueSize: z.ZodOptional<z.ZodNumber>;
+    dropPolicy: z.ZodOptional<z.ZodEnum<{
+        "drop-oldest": "drop-oldest";
+        "drop-newest": "drop-newest";
+    }>>;
+    requestTimeout: z.ZodOptional<z.ZodNumber>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    companyId: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodString;
+    broadcast: z.ZodOptional<z.ZodBoolean>;
+    bot: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    includeTimestamp: z.ZodOptional<z.ZodBoolean>;
+    includeMeta: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const RelayConfigSchema: z.ZodType<RelayConfig>;
 declare const LevelConfigObjectSchema: z.ZodType<LevelConfigObject>;
 declare const LevelConfigSchema: z.ZodType<LevelConfig>;
 declare const CallerConfigSchema: z.ZodType<CallerConfig>;
@@ -412,6 +617,62 @@ declare const LoggerConfigSchema: z.ZodObject<{
     discord: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<DiscordConfig, unknown, z.core.$ZodTypeInternals<DiscordConfig, unknown>>, z.ZodArray<z.ZodType<DiscordConfig, unknown, z.core.$ZodTypeInternals<DiscordConfig, unknown>>>]>>;
     telegram: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<TelegramConfig, unknown, z.core.$ZodTypeInternals<TelegramConfig, unknown>>, z.ZodArray<z.ZodType<TelegramConfig, unknown, z.core.$ZodTypeInternals<TelegramConfig, unknown>>>]>>;
     cloudwatch: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<CloudWatchConfig, unknown, z.core.$ZodTypeInternals<CloudWatchConfig, unknown>>, z.ZodArray<z.ZodType<CloudWatchConfig, unknown, z.core.$ZodTypeInternals<CloudWatchConfig, unknown>>>]>>;
+    zohoCliq: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        level: z.ZodOptional<z.ZodType<"off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly", unknown, z.core.$ZodTypeInternals<"off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly", unknown>>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodType<LevelRule, unknown, z.core.$ZodTypeInternals<LevelRule, unknown>>>>;
+        batchSize: z.ZodOptional<z.ZodNumber>;
+        flushInterval: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        retryDelay: z.ZodOptional<z.ZodNumber>;
+        onError: z.ZodType<HttpTransportBaseConfig["onError"]>;
+        onDrop: z.ZodType<HttpTransportBaseConfig["onDrop"]>;
+        maxQueueSize: z.ZodOptional<z.ZodNumber>;
+        dropPolicy: z.ZodOptional<z.ZodEnum<{
+            "drop-oldest": "drop-oldest";
+            "drop-newest": "drop-newest";
+        }>>;
+        requestTimeout: z.ZodOptional<z.ZodNumber>;
+        webhookUrl: z.ZodOptional<z.ZodString>;
+        companyId: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodString;
+        broadcast: z.ZodOptional<z.ZodBoolean>;
+        bot: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            image: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        includeTimestamp: z.ZodOptional<z.ZodBoolean>;
+        includeMeta: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        level: z.ZodOptional<z.ZodType<"off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly", unknown, z.core.$ZodTypeInternals<"off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly", unknown>>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodType<LevelRule, unknown, z.core.$ZodTypeInternals<LevelRule, unknown>>>>;
+        batchSize: z.ZodOptional<z.ZodNumber>;
+        flushInterval: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        retryDelay: z.ZodOptional<z.ZodNumber>;
+        onError: z.ZodType<HttpTransportBaseConfig["onError"]>;
+        onDrop: z.ZodType<HttpTransportBaseConfig["onDrop"]>;
+        maxQueueSize: z.ZodOptional<z.ZodNumber>;
+        dropPolicy: z.ZodOptional<z.ZodEnum<{
+            "drop-oldest": "drop-oldest";
+            "drop-newest": "drop-newest";
+        }>>;
+        requestTimeout: z.ZodOptional<z.ZodNumber>;
+        webhookUrl: z.ZodOptional<z.ZodString>;
+        companyId: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodString;
+        broadcast: z.ZodOptional<z.ZodBoolean>;
+        bot: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            image: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        includeTimestamp: z.ZodOptional<z.ZodBoolean>;
+        includeMeta: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>]>>;
+    relay: z.ZodOptional<z.ZodType<RelayConfig, unknown, z.core.$ZodTypeInternals<RelayConfig, unknown>>>;
     caller: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodType<CallerConfig, unknown, z.core.$ZodTypeInternals<CallerConfig, unknown>>]>>;
     hostname: z.ZodOptional<z.ZodString>;
     autoShutdown: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodType<AutoShutdownConfig, unknown, z.core.$ZodTypeInternals<AutoShutdownConfig, unknown>>]>>;
@@ -424,9 +685,59 @@ declare function safeValidateConfig(config: unknown): z.ZodSafeParseResult<{
     discord?: DiscordConfig | DiscordConfig[] | undefined;
     telegram?: TelegramConfig | TelegramConfig[] | undefined;
     cloudwatch?: CloudWatchConfig | CloudWatchConfig[] | undefined;
+    zohoCliq?: {
+        onError: ((error: Error, droppedMessages: unknown[]) => void) | undefined;
+        onDrop: ((droppedMessages: unknown[]) => void) | undefined;
+        apiKey: string;
+        level?: "off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly" | undefined;
+        rules?: LevelRule[] | undefined;
+        batchSize?: number | undefined;
+        flushInterval?: number | undefined;
+        maxRetries?: number | undefined;
+        retryDelay?: number | undefined;
+        maxQueueSize?: number | undefined;
+        dropPolicy?: "drop-oldest" | "drop-newest" | undefined;
+        requestTimeout?: number | undefined;
+        webhookUrl?: string | undefined;
+        companyId?: string | undefined;
+        channel?: string | undefined;
+        region?: string | undefined;
+        broadcast?: boolean | undefined;
+        bot?: {
+            name: string;
+            image?: string | undefined;
+        } | undefined;
+        includeTimestamp?: boolean | undefined;
+        includeMeta?: boolean | undefined;
+    } | {
+        onError: ((error: Error, droppedMessages: unknown[]) => void) | undefined;
+        onDrop: ((droppedMessages: unknown[]) => void) | undefined;
+        apiKey: string;
+        level?: "off" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly" | undefined;
+        rules?: LevelRule[] | undefined;
+        batchSize?: number | undefined;
+        flushInterval?: number | undefined;
+        maxRetries?: number | undefined;
+        retryDelay?: number | undefined;
+        maxQueueSize?: number | undefined;
+        dropPolicy?: "drop-oldest" | "drop-newest" | undefined;
+        requestTimeout?: number | undefined;
+        webhookUrl?: string | undefined;
+        companyId?: string | undefined;
+        channel?: string | undefined;
+        region?: string | undefined;
+        broadcast?: boolean | undefined;
+        bot?: {
+            name: string;
+            image?: string | undefined;
+        } | undefined;
+        includeTimestamp?: boolean | undefined;
+        includeMeta?: boolean | undefined;
+    }[] | undefined;
+    relay?: RelayConfig | undefined;
     caller?: boolean | CallerConfig | undefined;
     hostname?: string | undefined;
     autoShutdown?: boolean | AutoShutdownConfig | undefined;
 }>;
 
-export { type AutoShutdownConfig, AutoShutdownConfigSchema, BaseHttpTransport, type BaseHttpTransportOptions, type BufferOptions, type BufferedMessage, type CallerConfig, CallerConfigSchema, type CallerInfo, type CloudWatchConfig, CloudWatchConfigSchema, CloudWatchTransport, type ConsoleConfig, ConsoleConfigSchema, type DiscordConfig, DiscordConfigSchema, DiscordTransport, type FileConfig, FileConfigSchema, type GracefulShutdownOptions, type HttpErrorData, type HttpTransportBaseConfig, HttpTransportBaseConfigSchema, LOG_LEVELS, type LevelConfig, type LevelConfigObject, LevelConfigObjectSchema, LevelConfigSchema, type LevelOverride, type LevelOverrideMatch, type LevelRule, LevelRuleSchema, type LogFormat, LogFormatSchema, type LogLevel, LogLevelSchema, type LogStreamName, LogStreamNameSchema, type LogStreamPattern, type LogStreamPatternConfig, LogStreamPatternConfigSchema, LogStreamPatternSchema, type LogStreamTemplateConfig, LogStreamTemplateConfigSchema, Logger, type LoggerConfig, LoggerConfigSchema, type LoggerContext, LoggerStore, type MaskSecretsOptions, MessageBuffer, type Meta, type RequestIdOptions, type SerializedError, type SingletonLogger, type TelegramConfig, TelegramConfigSchema, TelegramTransport, type TimingResult, assertLogLevel, createMasker, createSingletonLogger, extractRequestId, flattenObject, formatCallerInfo, formatLogfmt, formatLogfmtValue, generateRequestId, getCallerInfo, getOrGenerateRequestId, isValidLogLevel, maskSecrets, matchesContext, measureAsync, measureSync, registerShutdown, safeValidateConfig, serializeError, validateConfig };
+export { type AutoShutdownConfig, AutoShutdownConfigSchema, BaseHttpTransport, type BaseHttpTransportOptions, type BufferOptions, type BufferedMessage, type CallerConfig, CallerConfigSchema, type CallerInfo, type CloudWatchConfig, CloudWatchConfigSchema, CloudWatchTransport, type ConsoleConfig, ConsoleConfigSchema, type DiscordConfig, DiscordConfigSchema, DiscordTransport, type FileConfig, FileConfigSchema, type GracefulShutdownOptions, type HttpErrorData, type HttpTransportBaseConfig, HttpTransportBaseConfigSchema, LOG_LEVELS, type LevelConfig, type LevelConfigObject, LevelConfigObjectSchema, LevelConfigSchema, type LevelOverride, type LevelOverrideMatch, type LevelRule, LevelRuleSchema, type LogFormat, LogFormatSchema, type LogLevel, LogLevelSchema, type LogStreamName, LogStreamNameSchema, type LogStreamPattern, type LogStreamPatternConfig, LogStreamPatternConfigSchema, LogStreamPatternSchema, type LogStreamTemplateConfig, LogStreamTemplateConfigSchema, Logger, type LoggerConfig, LoggerConfigSchema, type LoggerContext, LoggerStore, type MaskSecretsOptions, MessageBuffer, type Meta, type RelayConfig, RelayConfigSchema, type RequestIdOptions, type SerializedError, type SingletonLogger, type TelegramConfig, TelegramConfigSchema, TelegramTransport, type TimingResult, type ZohoCliqBotConfig, type ZohoCliqConfig, ZohoCliqConfigSchema, ZohoCliqTransport, assertLogLevel, createMasker, createSingletonLogger, extractRequestId, flattenObject, formatCallerInfo, formatLogfmt, formatLogfmtValue, generateRequestId, getCallerInfo, getOrGenerateRequestId, isValidLogLevel, maskSecrets, matchesContext, measureAsync, measureSync, registerShutdown, safeValidateConfig, serializeError, validateConfig };