@loggerjs/node API

Generated from packages/node/dist/**/*.d.ts. Source report: api-reports/loggerjs-node.api.md.

bullmq-integration.d.ts

import { type QueueClientLike, type QueueIntegrationOptions } from "./queue-integration.js";
export interface BullMqIntegrationOptions extends Omit<QueueIntegrationOptions, "client" | "system" | "methods" | "getQueueName"> {
    /**
     * Queue-like BullMQ object. By default LoggerJS wraps `add`, `addBulk`, and a
     * legacy `process` method when present; it does not hook `Worker` or
     * `QueueEvents` lifecycle events such as `completed`, `failed`, or `stalled`.
     */
    client: QueueClientLike & {
        name?: string;
    };
    methods?: readonly string[];
}
export declare function bullMqIntegration(options: BullMqIntegrationOptions): import("@loggerjs/core").Integration;

cli-integration.d.ts

import { type Integration, type LoggerLevel } from "@loggerjs/core";
export interface CliProcessLike {
    argv?: readonly string[];
    env?: Record<string, string | undefined>;
    exitCode?: number | string | null;
    cwd?: () => string;
    on?: (event: string, listener: (...args: unknown[]) => void) => unknown;
    off?: (event: string, listener: (...args: unknown[]) => void) => unknown;
    removeListener?: (event: string, listener: (...args: unknown[]) => void) => unknown;
}
export interface CaptureCliOptions {
    name?: string;
    process?: CliProcessLike;
    captureStart?: boolean;
    captureExit?: boolean;
    captureSignals?: boolean;
    captureCwd?: boolean;
    captureEnv?: readonly string[];
    signals?: readonly string[];
    level?: LoggerLevel | ((event: "start" | "exit" | "signal", code?: number | string) => LoggerLevel);
    getCommand?: (argv: readonly string[]) => string | undefined;
    sanitizeArg?: (arg: string, index: number, argv: readonly string[]) => string;
}
export declare function captureCliIntegration(options?: CaptureCliOptions): Integration;

context.d.ts

import { AsyncLocalStorage } from "node:async_hooks";
import { type ContextManager } from "@loggerjs/core";
export declare function createAsyncLocalStorageContextManager(storage?: AsyncLocalStorage<Readonly<Record<string, unknown>>>): ContextManager & {
    disable: () => void;
};
export declare function installAsyncLocalStorageContext(manager?: ContextManager & {
    disable: () => void;
}): () => void;

database-integration.d.ts

import { type Integration, type LoggerLevel } from "@loggerjs/core";
export interface DatabaseClientLike {
    [method: string]: unknown;
}
export interface DatabaseIntegrationTarget {
    client: DatabaseClientLike;
    name?: string;
    system?: string;
    methods?: readonly string[];
}
export interface DatabaseOperationInfo {
    target: string;
    system?: string;
    method: string;
    statement?: string;
}
export interface DatabaseIntegrationOptions {
    client?: DatabaseClientLike;
    targets?: readonly DatabaseIntegrationTarget[];
    name?: string;
    system?: string;
    methods?: readonly string[];
    captureAll?: boolean;
    captureSuccessful?: boolean;
    minDurationMs?: number;
    sampleRate?: number;
    random?: () => number;
    captureParameters?: boolean;
    sanitizeStatement?: (statement: string) => string;
    getStatement?: (args: readonly unknown[], method: string) => string | undefined;
    level?: (durationMs: number, error: unknown, info: DatabaseOperationInfo) => LoggerLevel;
}
export declare function databaseIntegration(options?: DatabaseIntegrationOptions): Integration;

diagnostics-channel-integration.d.ts

import { type Integration } from "@loggerjs/core";
export interface DiagnosticsChannelModule {
    subscribe: (name: string, listener: (message: unknown, name: string) => void) => void;
    unsubscribe?: (name: string, listener: (message: unknown, name: string) => void) => void;
}
export interface DiagnosticsChannelIntegrationOptions {
    channels?: readonly string[];
    diagnosticsChannel?: DiagnosticsChannelModule | null;
    captureMessage?: boolean;
}
export declare function diagnosticsChannelIntegration(options?: DiagnosticsChannelIntegrationOptions): Integration;

express-integration.d.ts

import { type LoggerLevel, type LoggerLike } from "@loggerjs/core";
export interface ExpressRequestLike {
    method?: string;
    originalUrl?: string;
    url?: string;
    path?: string;
    headers?: Record<string, string | string[] | undefined>;
    ip?: string;
    route?: {
        path?: string;
    };
    socket?: {
        remoteAddress?: string;
    };
    [key: string]: unknown;
}
export interface ExpressResponseLike {
    statusCode?: number;
    writableEnded?: boolean;
    headersSent?: boolean;
    getHeader?: (name: string) => number | string | string[] | undefined;
    once?: (event: "finish" | "close", listener: () => void) => unknown;
    on?: (event: "finish" | "close", listener: () => void) => unknown;
    off?: (event: "finish" | "close", listener: () => void) => unknown;
    removeListener?: (event: "finish" | "close", listener: () => void) => unknown;
}
export type ExpressNextFunction = (error?: unknown) => void;
export type ExpressRequestHandler = (req: ExpressRequestLike, res: ExpressResponseLike, next: ExpressNextFunction) => void;
export interface ExpressIntegrationOptions {
    name?: string;
    minStatus?: number;
    captureAll?: boolean;
    captureSuccessful?: boolean;
    captureAborted?: boolean;
    sampleRate?: number;
    random?: () => number;
    bindContext?: boolean;
    captureRequestHeaders?: readonly string[];
    captureResponseHeaders?: readonly string[];
    sanitizeUrl?: (url: string) => string;
    getRequestId?: (req: ExpressRequestLike, res: ExpressResponseLike) => string | undefined;
    getRoute?: (req: ExpressRequestLike) => string | undefined;
    context?: (req: ExpressRequestLike, res: ExpressResponseLike) => Record<string, unknown> | undefined;
    level?: (status: number, req: ExpressRequestLike, res: ExpressResponseLike, aborted: boolean) => LoggerLevel;
}
export declare function expressIntegration(logger: LoggerLike, options?: ExpressIntegrationOptions): ExpressRequestHandler;

fastify-integration.d.ts

import { type LoggerLevel, type LoggerLike } from "@loggerjs/core";
export interface FastifyRequestLike {
    id?: string;
    method?: string;
    url?: string;
    headers?: Record<string, string | string[] | undefined>;
    ip?: string;
    routeOptions?: {
        url?: string;
    };
    routerPath?: string;
    [key: string]: unknown;
}
export interface FastifyReplyLike {
    statusCode?: number;
    getHeader?: (name: string) => number | string | string[] | undefined;
    [key: string]: unknown;
}
export type FastifyDone = (error?: unknown) => void;
export type FastifyOnRequestHook = (request: FastifyRequestLike, reply: FastifyReplyLike, done: FastifyDone) => void;
export type FastifyOnResponseHook = (request: FastifyRequestLike, reply: FastifyReplyLike, done: FastifyDone) => void;
export type FastifyOnErrorHook = (request: FastifyRequestLike, reply: FastifyReplyLike, error: unknown, done: FastifyDone) => void;
export interface FastifyInstanceLike {
    addHook: (name: "onRequest" | "onResponse" | "onError", hook: FastifyOnRequestHook | FastifyOnResponseHook | FastifyOnErrorHook) => unknown;
}
export type FastifyPluginCallback = (instance: FastifyInstanceLike, options: unknown, done?: FastifyDone) => void;
export interface FastifyIntegrationOptions {
    name?: string;
    minStatus?: number;
    captureAll?: boolean;
    captureSuccessful?: boolean;
    sampleRate?: number;
    random?: () => number;
    bindContext?: boolean;
    captureRequestHeaders?: readonly string[];
    captureResponseHeaders?: readonly string[];
    sanitizeUrl?: (url: string) => string;
    getRequestId?: (request: FastifyRequestLike, reply: FastifyReplyLike) => string | undefined;
    getRoute?: (request: FastifyRequestLike) => string | undefined;
    context?: (request: FastifyRequestLike, reply: FastifyReplyLike) => Record<string, unknown> | undefined;
    level?: (status: number, request: FastifyRequestLike, reply: FastifyReplyLike, error: unknown) => LoggerLevel;
}
export declare function fastifyIntegration(logger: LoggerLike, options?: FastifyIntegrationOptions): FastifyPluginCallback;

file-transport.d.ts

import { type Codec, type LoggerLevel, type Transport } from "@loggerjs/core";
import type { WriteStream } from "fs";
export interface FileTransportOptions {
    path: string;
    name?: string;
    codec?: Codec<string | Uint8Array>;
    minLevel?: LoggerLevel;
    flags?: string;
    append?: boolean;
    mkdir?: boolean;
    sync?: boolean;
    minLength?: number;
}
export interface FileTransport extends Transport {
    stream?: WriteStream;
    flushSync: () => void;
}
export declare function fileTransport(options: FileTransportOptions): FileTransport;

hapi-integration.d.ts

import { type LoggerLevel, type LoggerLike } from "@loggerjs/core";
export interface HapiRequestLike {
    method?: string;
    path?: string;
    url?: {
        pathname?: string;
    };
    info?: {
        id?: string;
        received?: number;
        remoteAddress?: string;
    };
    response?: {
        statusCode?: number;
    } | {
        isBoom?: boolean;
        output?: {
            statusCode?: number;
        };
    };
    app?: Record<string, unknown>;
}
export interface HapiToolkitLike {
    continue: unknown;
}
export interface HapiServerLike {
    ext: (event: "onRequest", handler: (request: HapiRequestLike, h: HapiToolkitLike) => unknown) => unknown;
    events?: {
        on?: (event: "response", handler: (request: HapiRequestLike) => void) => unknown;
    };
}
export interface HapiIntegrationOptions {
    minStatus?: number;
    captureAll?: boolean;
    bindContext?: boolean;
    getRequestId?: (request: HapiRequestLike) => string | undefined;
    context?: (request: HapiRequestLike) => Record<string, unknown> | undefined;
    level?: (status: number, request: HapiRequestLike) => LoggerLevel;
}
export declare function hapiIntegration(logger: LoggerLike, options?: HapiIntegrationOptions): {
    name: string;
    register(server: HapiServerLike): void;
};

http-transport.d.ts

import { type BatchTransportOptions, type Codec, type LoggerLevel, type PayloadTransform, type Transport } from "@loggerjs/core";
export interface NodeHttpTransportOptions extends BatchTransportOptions {
    url: string;
    name?: string;
    method?: "POST" | "PUT";
    headers?: Record<string, string>;
    codec?: Codec<string | Uint8Array>;
    minLevel?: LoggerLevel;
    fetchFn?: typeof fetch;
    transformPayload?: PayloadTransform | readonly PayloadTransform[];
}
export declare function nodeHttpTransport(options: NodeHttpTransportOptions): Transport;

index.d.ts

export * from "@loggerjs/core";
export * from "./stdout-transport.js";
export * from "./file-transport.js";
export * from "./rotating-file-transport.js";
export * from "./http-transport.js";
export * from "./payload-transforms.js";
export * from "./syslog-transport.js";
export * from "./worker-transport.js";
export * from "./context.js";
export * from "./bullmq-integration.js";
export * from "./cli-integration.js";
export * from "./database-integration.js";
export * from "./express-integration.js";
export * from "./fastify-integration.js";
export * from "./hapi-integration.js";
export * from "./koa-integration.js";
export * from "./nest-integration.js";
export * from "./node-fetch-integration.js";
export * from "./node-http-client-integration.js";
export * from "./process-integration.js";
export * from "./prisma-integration.js";
export * from "./queue-integration.js";
export * from "./redis-integration.js";
export * from "./serverless-integration.js";
export * from "./diagnostics-channel-integration.js";
export * from "./logger-diagnostics.js";

internal-types.d.ts

export interface WritableLike {
    write: (chunk: string | Uint8Array, callback?: (error?: Error | null) => void) => unknown;
    on?: (event: "error", listener: (error: Error) => void) => unknown;
    off?: (event: "error", listener: (error: Error) => void) => unknown;
    once?: (event: "drain", listener: () => void) => unknown;
    end?: (callback?: (error?: Error | null) => void) => unknown;
}

koa-integration.d.ts

import { type LoggerLevel, type LoggerLike } from "@loggerjs/core";
export interface KoaContextLike {
    method?: string;
    originalUrl?: string;
    url?: string;
    path?: string;
    status?: number;
    ip?: string;
    state?: Record<string, unknown>;
    request?: {
        headers?: Record<string, string | string[] | undefined>;
    };
}
export type KoaNext = () => Promise<unknown>;
export type KoaMiddleware = (ctx: KoaContextLike, next: KoaNext) => Promise<void>;
export interface KoaIntegrationOptions {
    minStatus?: number;
    captureAll?: boolean;
    bindContext?: boolean;
    sanitizeUrl?: (url: string) => string;
    getRequestId?: (ctx: KoaContextLike) => string | undefined;
    context?: (ctx: KoaContextLike) => Record<string, unknown> | undefined;
    level?: (status: number, ctx: KoaContextLike, error: unknown) => LoggerLevel;
}
export declare function koaIntegration(logger: LoggerLike, options?: KoaIntegrationOptions): KoaMiddleware;

logger-diagnostics.d.ts

import { type LoggerDiagnosticEvent } from "@loggerjs/core";
export interface LoggerDiagnosticsChannelPublisher {
    hasSubscribers?: boolean;
    publish: (message: LoggerDiagnosticEvent) => void;
}
export interface LoggerDiagnosticsChannelModule {
    channel: (name: string) => LoggerDiagnosticsChannelPublisher;
}
export interface InstallLoggerDiagnosticsChannelOptions {
    diagnosticsChannel?: LoggerDiagnosticsChannelModule | null;
    prefix?: string;
}
export declare function installLoggerDiagnosticsChannel(options?: InstallLoggerDiagnosticsChannelOptions): () => void;

nest-integration.d.ts

import type { LoggerLike } from "@loggerjs/core";
import { type ExpressIntegrationOptions, type ExpressRequestHandler } from "./express-integration.js";
export type NestMiddleware = ExpressRequestHandler;
/**
 * Express-compatible Nest middleware adapter. It observes the same request and
 * response completion surface as `expressIntegration`; it does not hook Nest
 * exception filters, interceptors, guards, or the original thrown `Error`.
 */
export declare function nestMiddlewareIntegration(logger: LoggerLike, options?: ExpressIntegrationOptions): NestMiddleware;

node-destination.d.ts

import { type WriteStream } from "fs";
import type { TransportContext } from "@loggerjs/core";
import type { WritableLike } from "./internal-types.js";
export interface NodeDestination {
    stream?: WriteStream;
    write: (payload: string | Uint8Array, context?: TransportContext) => void;
    flush: () => Promise<void>;
    flushSync: () => void;
    close: () => Promise<void>;
    closeSync: () => void;
    releaseSync?: () => void;
}
export interface NodeStreamDestinationOptions {
    name: string;
    stream: WritableLike;
    minLength?: number;
    ignoreEpipe?: boolean;
    reportOperation?: string;
    syncWrite?: (payload: string | Uint8Array) => void;
}
export interface NodeFileDestinationOptions {
    name: string;
    path: string;
    flags?: string;
    append?: boolean;
    mkdir?: boolean;
    sync?: boolean;
    minLength?: number;
}
export declare function createNodeStreamDestination(options: NodeStreamDestinationOptions): NodeDestination;
export declare function createNodeFileDestination(options: NodeFileDestinationOptions): NodeDestination;

node-fetch-integration.d.ts

import { type Integration, type LoggerLevel } from "@loggerjs/core";
export interface NodeFetchHeadersLike {
    get?: (name: string) => string | null;
    [key: string]: unknown;
}
export interface NodeFetchRequestLike {
    url?: string;
    method?: string;
    headers?: NodeFetchHeadersLike | Record<string, unknown>;
}
export interface NodeFetchInitLike {
    method?: string;
    headers?: NodeFetchHeadersLike | Record<string, unknown>;
}
export interface NodeFetchResponseLike {
    status?: number;
    headers?: NodeFetchHeadersLike | Record<string, unknown>;
}
export type NodeFetchFunction = (input: string | URL | NodeFetchRequestLike, init?: NodeFetchInitLike) => Promise<NodeFetchResponseLike>;
export interface NodeFetchTargetLike {
    fetch?: NodeFetchFunction;
}
export interface NodeFetchRequestInfo {
    method: string;
    url: string;
    requestHeaders?: Record<string, string>;
}
export interface NodeFetchIntegrationOptions {
    name?: string;
    minStatus?: number;
    captureAll?: boolean;
    captureSuccessful?: boolean;
    sampleRate?: number;
    random?: () => number;
    captureRequestHeaders?: readonly string[];
    captureResponseHeaders?: readonly string[];
    sanitizeUrl?: (url: string) => string;
    level?: (status: number | undefined, error: unknown, info: NodeFetchRequestInfo) => LoggerLevel;
    target?: NodeFetchTargetLike;
}
export declare function nodeFetchIntegration(options?: NodeFetchIntegrationOptions): Integration;

node-http-client-integration.d.ts

import { type Integration, type LoggerLevel } from "@loggerjs/core";
export interface NodeHttpClientRequestLike {
    once?: (event: "response" | "error", listener: (...args: unknown[]) => void) => unknown;
    on?: (event: "response" | "error", listener: (...args: unknown[]) => void) => unknown;
    off?: (event: "response" | "error", listener: (...args: unknown[]) => void) => unknown;
    removeListener?: (event: "response" | "error", listener: (...args: unknown[]) => void) => unknown;
    end?: (...args: unknown[]) => unknown;
}
export interface NodeHttpIncomingMessageLike {
    statusCode?: number;
    headers?: Record<string, number | string | string[] | undefined>;
}
export type NodeHttpRequestFunction = (this: unknown, ...args: unknown[]) => NodeHttpClientRequestLike;
export interface NodeHttpModuleLike {
    request?: NodeHttpRequestFunction;
    get?: NodeHttpRequestFunction;
}
export interface NodeHttpClientRequestInfo {
    protocol: "http:" | "https:" | string;
    method: string;
    url: string;
    requestHeaders?: Record<string, string | string[]>;
}
export interface NodeHttpClientIntegrationOptions {
    name?: string;
    minStatus?: number;
    captureAll?: boolean;
    captureSuccessful?: boolean;
    sampleRate?: number;
    random?: () => number;
    captureRequestHeaders?: readonly string[];
    captureResponseHeaders?: readonly string[];
    sanitizeUrl?: (url: string) => string;
    level?: (status: number | undefined, error: unknown, info: NodeHttpClientRequestInfo) => LoggerLevel;
    httpModule?: NodeHttpModuleLike | null;
    httpsModule?: NodeHttpModuleLike | null;
}
export declare function nodeHttpClientIntegration(options?: NodeHttpClientIntegrationOptions): Integration;

payload-transforms.d.ts

import { type BrotliOptions, type ZlibOptions } from "node:zlib";
import { type PayloadTransform } from "@loggerjs/core";
export type NodeCompressionFormat = "gzip" | "brotli" | "deflate";
export interface NodeCompressionPayloadTransformOptions {
    format?: NodeCompressionFormat;
    gzipOptions?: ZlibOptions;
    brotliOptions?: BrotliOptions;
    deflateOptions?: ZlibOptions;
    headers?: Record<string, string>;
}
export declare function nodeCompressionPayloadTransform(options?: NodeCompressionPayloadTransformOptions): PayloadTransform;

prisma-integration.d.ts

import { type DatabaseClientLike, type DatabaseIntegrationOptions } from "./database-integration.js";
export interface PrismaIntegrationOptions extends Omit<DatabaseIntegrationOptions, "client" | "system" | "methods" | "getStatement"> {
    /**
     * Prisma-like client whose raw query methods should be wrapped. This adapter
     * does not subscribe to `$on("query")` and does not capture typed model
     * operations such as `prisma.user.findMany()`.
     */
    client: DatabaseClientLike;
}
export declare function prismaIntegration(options: PrismaIntegrationOptions): import("@loggerjs/core").Integration;

process-integration.d.ts

import { type Integration } from "@loggerjs/core";
export type ProcessSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGTERM";
export interface CaptureProcessOptions {
    uncaughtException?: boolean;
    unhandledRejection?: boolean;
    warning?: boolean;
    beforeExitFlush?: boolean;
    exitFlush?: boolean;
    signalFlush?: boolean;
    signals?: ProcessSignal[];
    exitOnSignal?: boolean;
    exitOnUncaught?: boolean;
    flushTimeoutMs?: number;
    exitFn?: (code: number) => void;
}
export declare function captureProcessIntegration(options?: CaptureProcessOptions): Integration;

queue-integration.d.ts

import { type Integration, type LoggerLevel } from "@loggerjs/core";
export type QueueOperation = "publish" | "consume" | "ack" | "nack" | "other";
export interface QueueClientLike {
    [method: string]: unknown;
}
export interface QueueIntegrationTarget {
    client: QueueClientLike;
    name?: string;
    system?: string;
    queueName?: string;
    methods?: readonly string[];
}
export interface QueueOperationInfo {
    target: string;
    system?: string;
    queueName?: string;
    method: string;
    operation: QueueOperation;
}
export interface QueueIntegrationOptions {
    client?: QueueClientLike;
    targets?: readonly QueueIntegrationTarget[];
    name?: string;
    system?: string;
    queueName?: string;
    methods?: readonly string[];
    captureAll?: boolean;
    captureSuccessful?: boolean;
    minDurationMs?: number;
    sampleRate?: number;
    random?: () => number;
    capturePayload?: boolean;
    getOperation?: (method: string, args: readonly unknown[]) => QueueOperation;
    getQueueName?: (args: readonly unknown[], method: string) => string | undefined;
    getMessageId?: (args: readonly unknown[], method: string) => string | undefined;
    getPayload?: (args: readonly unknown[], method: string) => unknown;
    level?: (durationMs: number, error: unknown, info: QueueOperationInfo) => LoggerLevel;
}
export declare function queueIntegration(options?: QueueIntegrationOptions): Integration;

redis-integration.d.ts

import { type DatabaseClientLike, type DatabaseIntegrationOptions } from "./database-integration.js";
export interface RedisIntegrationOptions extends Omit<DatabaseIntegrationOptions, "client" | "system" | "methods" | "getStatement"> {
    client: DatabaseClientLike;
    methods?: readonly string[];
}
export declare function redisIntegration(options: RedisIntegrationOptions): import("@loggerjs/core").Integration;

rotating-file-transport.d.ts

import { type Codec, type LoggerLevel, type Transport } from "@loggerjs/core";
export interface RotatingFileTransportOptions {
    path: string;
    name?: string;
    codec?: Codec<string | Uint8Array>;
    minLevel?: LoggerLevel;
    flags?: string;
    append?: boolean;
    mkdir?: boolean;
    maxBytes?: number;
    maxFiles?: number;
    archivePath?: (path: string, index: number) => string;
}
export interface RotatingFileTransport extends Transport {
    rotate: () => void;
    flushSync: () => void;
    currentBytes: () => number;
}
export declare function rotatingFileTransport(options: RotatingFileTransportOptions): RotatingFileTransport;

serverless-integration.d.ts

import { type LoggerLevel, type LoggerLike } from "@loggerjs/core";
export type ServerlessCallback<TResult> = (error?: unknown, result?: TResult) => void;
export type ServerlessHandler<TEvent, TContext, TResult> = (event: TEvent, context: TContext, callback?: ServerlessCallback<TResult>) => TResult | Promise<TResult> | void;
export interface ServerlessContextLike {
    awsRequestId?: string;
    functionName?: string;
    functionVersion?: string;
    invokedFunctionArn?: string;
    [key: string]: unknown;
}
export interface ServerlessEventLike {
    httpMethod?: string;
    path?: string;
    rawPath?: string;
    routeKey?: string;
    headers?: Record<string, string | undefined>;
    requestContext?: {
        requestId?: string;
        http?: {
            method?: string;
            path?: string;
        };
        routeKey?: string;
    };
    [key: string]: unknown;
}
export interface ServerlessInvocationInfo<TEvent, TContext> {
    event: TEvent;
    context: TContext;
    requestId?: string;
    operation?: string;
}
export interface ServerlessIntegrationOptions<TEvent, TContext, TResult> {
    name?: string;
    platform?: string;
    captureSuccessful?: boolean;
    captureAll?: boolean;
    sampleRate?: number;
    random?: () => number;
    captureEvent?: boolean;
    captureResult?: boolean;
    bindContext?: boolean;
    getRequestId?: (event: TEvent, context: TContext) => string | undefined;
    getOperation?: (event: TEvent, context: TContext) => string | undefined;
    level?: (error: unknown, durationMs: number, info: ServerlessInvocationInfo<TEvent, TContext>) => LoggerLevel;
    normalizeEvent?: (event: TEvent) => unknown;
    normalizeResult?: (result: TResult) => unknown;
}
export declare function serverlessIntegration<TEvent, TContext, TResult>(logger: LoggerLike, handler: ServerlessHandler<TEvent, TContext, TResult>, options?: ServerlessIntegrationOptions<TEvent, TContext, TResult>): ServerlessHandler<TEvent, TContext, TResult>;

stdout-transport.d.ts

import { type Codec, type LoggerLevel, type Transport } from "@loggerjs/core";
import type { WritableLike } from "./internal-types.js";
export interface StdoutTransportOptions {
    name?: string;
    stream?: WritableLike;
    codec?: Codec<string | Uint8Array>;
    minLevel?: LoggerLevel;
    minLength?: number;
    ignoreEpipe?: boolean;
}
export declare function stdoutTransport(options?: StdoutTransportOptions): Transport;
export declare function stderrTransport(options?: Omit<StdoutTransportOptions, "stream">): Transport;

syslog-transport.d.ts

import { type LogEvent, type LoggerLevel, type Transport } from "@loggerjs/core";
export type NodeSyslogProtocol = "tcp" | "udp4" | "udp6";
export type NodeSyslogTcpFraming = "newline" | "octet-counting";
export interface NodeSyslogUdpSocket {
    send: (message: string | Uint8Array, port: number, host: string, callback?: (error: Error | null | undefined) => void) => void;
    close?: () => void;
    on?: (event: "error", listener: (error: Error) => void) => void;
    unref?: () => void;
}
export interface NodeSyslogTcpSocket {
    write: (message: string | Uint8Array, callback?: (error?: Error | null) => void) => boolean;
    end?: () => void;
    destroy?: () => void;
    on?: (event: "error", listener: (error: Error) => void) => void;
    unref?: () => void;
}
export type NodeSyslogUdpSocketFactory = (protocol: "udp4" | "udp6") => NodeSyslogUdpSocket;
export type NodeSyslogTcpSocketFactory = (options: {
    host: string;
    port: number;
}) => NodeSyslogTcpSocket;
export interface NodeSyslogFormatOptions {
    facility?: number;
    hostname?: string;
    appName?: string | ((event: LogEvent) => string);
    procId?: string | number | ((event: LogEvent) => string | number);
    msgId?: string | ((event: LogEvent) => string);
    structuredData?: string | ((event: LogEvent) => string);
    formatMessage?: (event: LogEvent) => string;
}
export interface NodeSyslogTransportOptions extends NodeSyslogFormatOptions {
    name?: string;
    minLevel?: LoggerLevel;
    protocol?: NodeSyslogProtocol;
    host?: string;
    port?: number;
    tcpFraming?: NodeSyslogTcpFraming;
    unref?: boolean;
    udpSocketFactory?: NodeSyslogUdpSocketFactory;
    tcpSocketFactory?: NodeSyslogTcpSocketFactory;
    onError?: (error: unknown, detail: {
        operation: string;
    }) => void;
}
export declare function formatSyslogMessage(event: LogEvent, options?: NodeSyslogFormatOptions): string;
export declare function nodeSyslogTransport(options?: NodeSyslogTransportOptions): Transport;

worker-transport.d.ts

import { type Codec, type LoggerLevel, type Transport } from "@loggerjs/core";
export interface WorkerLike {
    postMessage: (value: unknown, transferList?: ArrayBuffer[]) => void;
    terminate?: () => void | number | Promise<number>;
    on?: (event: "error" | "exit" | "message", listener: (...args: unknown[]) => void) => unknown;
    off?: (event: "error" | "exit" | "message", listener: (...args: unknown[]) => void) => unknown;
}
export interface WorkerTransportMessage {
    type: "loggerjs:batch";
    id?: number;
    codec: string;
    contentType: string;
    count: number;
    payload: Uint8Array;
}
export type WorkerTransportProtocolMessage = {
    type: "loggerjs:ready";
} | {
    type: "loggerjs:batch:ack";
    id: number;
} | {
    type: "loggerjs:error";
    error?: unknown;
    message?: string;
};
export interface WorkerTransportOptions {
    name?: string;
    worker?: WorkerLike;
    workerFactory?: () => WorkerLike;
    workerScript?: string | URL;
    workerOptions?: object;
    fallback?: Transport;
    codec?: Codec<string | Uint8Array>;
    minLevel?: LoggerLevel;
    transferBuffers?: boolean;
    readyTimeoutMs?: number;
    ackTimeoutMs?: number;
    autoEnd?: boolean;
}
export declare function workerTransport(options?: WorkerTransportOptions): Transport;