@contrast/agent-bundle 5.46.0 → 5.48.0

package/node_modules/pino/pino.d.ts

@@ -20,118 +20,120 @@ import * as pinoStdSerializers from "pino-std-serializers";
 import type { SonicBoom, SonicBoomOpts } from "sonic-boom";
 import type { WorkerOptions } from "worker_threads";
 
+declare namespace pino {
+    //// Non-exported types and interfaces
 
+    // ToDo https://github.com/pinojs/thread-stream/issues/24
+    type ThreadStream = any
 
-//// Non-exported types and interfaces
-
-// ToDo https://github.com/pinojs/thread-stream/issues/24
-type ThreadStream = any
-
-type TimeFn = () => string;
-type MixinFn = (mergeObject: object, level: number) => object;
-type MixinMergeStrategyFn = (mergeObject: object, mixinObject: object) => object;
-
-type CustomLevelLogger<CustomLevels extends string> = { [level in CustomLevels]: LogFn }
+    type TimeFn = () => string;
+    type MixinFn<CustomLevels extends string = never> = (mergeObject: object, level: number, logger:Logger<CustomLevels>) => object;
+    type MixinMergeStrategyFn = (mergeObject: object, mixinObject: object) => object;
 
-/**
-* A synchronous callback that will run on each creation of a new child.
-* @param child: The newly created child logger instance.
-*/
-type OnChildCallback<CustomLevels extends string = never> = (child: pino.Logger<CustomLevels>) => void
-
-export interface redactOptions {
-    paths: string[];
-    censor?: string | ((value: any, path: string[]) => any);
-    remove?: boolean;
-}
+    type CustomLevelLogger<CustomLevels extends string, UseOnlyCustomLevels extends boolean = boolean> = { 
+        /**
+         * Define additional logging levels.
+         */
+        customLevels: { [level in CustomLevels]: number };
+        /**
+         * Use only defined `customLevels` and omit Pino's levels.
+         */
+        useOnlyCustomLevels: UseOnlyCustomLevels;
+    } & {
+        // This will override default log methods
+        [K in Exclude<Level, CustomLevels>]: UseOnlyCustomLevels extends true ? never : LogFn;
+    } & {
+        [level in CustomLevels]: LogFn;
+    };
 
-export interface LoggerExtras<CustomLevels extends string = never> extends EventEmitter {
     /**
-     * Exposes the Pino package version. Also available on the exported pino function.
-     */
-    readonly version: string;
+    * A synchronous callback that will run on each creation of a new child.
+    * @param child: The newly created child logger instance.
+    */
+    type OnChildCallback<CustomLevels extends string = never> = (child: Logger<CustomLevels>) => void
+
+    export interface redactOptions {
+        paths: string[];
+        censor?: string | ((value: unknown, path: string[]) => unknown);
+        remove?: boolean;
+    }
 
-    levels: pino.LevelMapping;
+    export interface LoggerExtras<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> extends EventEmitter {
+        /**
+         * Exposes the Pino package version. Also available on the exported pino function.
+         */
+        readonly version: string;
 
-    /**
-     * Outputs the level as a string instead of integer.
-     */
-    useLevelLabels: boolean;
-    /**
-     * Define additional logging levels.
-     */
-    customLevels: { [level in CustomLevels]: number };
-    /**
-     * Use only defined `customLevels` and omit Pino's levels.
-     */
-    useOnlyCustomLevels: boolean;
-    /**
-     * Returns the integer value for the logger instance's logging level.
-     */
-    levelVal: number;
+        levels: LevelMapping;
 
-    /**
-     * Creates a child logger, setting all key-value pairs in `bindings` as properties in the log lines. All serializers will be applied to the given pair.
-     * Child loggers use the same output stream as the parent and inherit the current log level of the parent at the time they are spawned.
-     * From v2.x.x the log level of a child is mutable (whereas in v1.x.x it was immutable), and can be set independently of the parent.
-     * If a `level` property is present in the object passed to `child` it will override the child logger level.
-     *
-     * @param bindings: an object of key-value pairs to include in log lines as properties.
-     * @param options: an options object that will override child logger inherited options.
-     * @returns a child logger instance.
-     */
-    child<ChildCustomLevels extends string = never>(bindings: pino.Bindings, options?: ChildLoggerOptions<ChildCustomLevels>): pino.Logger<CustomLevels | ChildCustomLevels>;
+        /**
+         * Outputs the level as a string instead of integer.
+         */
+        useLevelLabels: boolean;
+        /**
+         * Returns the integer value for the logger instance's logging level.
+         */
+        levelVal: number;
 
-    /**
-     * This can be used to modify the callback function on creation of a new child.
-     */
-    onChild: OnChildCallback<CustomLevels>;
+        /**
+         * Creates a child logger, setting all key-value pairs in `bindings` as properties in the log lines. All serializers will be applied to the given pair.
+         * Child loggers use the same output stream as the parent and inherit the current log level of the parent at the time they are spawned.
+         * From v2.x.x the log level of a child is mutable (whereas in v1.x.x it was immutable), and can be set independently of the parent.
+         * If a `level` property is present in the object passed to `child` it will override the child logger level.
+         *
+         * @param bindings: an object of key-value pairs to include in log lines as properties.
+         * @param options: an options object that will override child logger inherited options.
+         * @returns a child logger instance.
+         */
+        child<ChildCustomLevels extends string = never>(bindings: Bindings, options?: ChildLoggerOptions<ChildCustomLevels>): Logger<CustomLevels | ChildCustomLevels>;
 
-    /**
-     * Registers a listener function that is triggered when the level is changed.
-     * Note: When browserified, this functionality will only be available if the `events` module has been required elsewhere
-     * (e.g. if you're using streams in the browser). This allows for a trade-off between bundle size and functionality.
-     *
-     * @param event: only ever fires the `'level-change'` event
-     * @param listener: The listener is passed four arguments: `levelLabel`, `levelValue`, `previousLevelLabel`, `previousLevelValue`.
-     */
-    on(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels>): this;
-    addListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels>): this;
-    once(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels>): this;
-    prependListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels>): this;
-    prependOnceListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels>): this;
-    removeListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels>): this;
+        /**
+         * This can be used to modify the callback function on creation of a new child.
+         */
+        onChild: OnChildCallback<CustomLevels>;
 
-    /**
-     * A utility method for determining if a given log level will write to the destination.
-     */
-    isLevelEnabled(level: pino.LevelWithSilentOrString): boolean;
+        /**
+         * Registers a listener function that is triggered when the level is changed.
+         * Note: When browserified, this functionality will only be available if the `events` module has been required elsewhere
+         * (e.g. if you're using streams in the browser). This allows for a trade-off between bundle size and functionality.
+         *
+         * @param event: only ever fires the `'level-change'` event
+         * @param listener: The listener is passed four arguments: `levelLabel`, `levelValue`, `previousLevelLabel`, `previousLevelValue`.
+         */
+        on(event: "level-change", listener: LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
+        addListener(event: "level-change", listener: LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
+        once(event: "level-change", listener: LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
+        prependListener(event: "level-change", listener: LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
+        prependOnceListener(event: "level-change", listener: LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
+        removeListener(event: "level-change", listener: LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
 
-    /**
-     * Returns an object containing all the current bindings, cloned from the ones passed in via logger.child().
-     */
-    bindings(): pino.Bindings;
+        /**
+         * A utility method for determining if a given log level will write to the destination.
+         */
+        isLevelEnabled(level: LevelWithSilentOrString): boolean;
 
-    /**
-     * Adds to the bindings of this logger instance.
-     * Note: Does not overwrite bindings. Can potentially result in duplicate keys in log lines.
-     *
-     * @param bindings: an object of key-value pairs to include in log lines as properties.
-     */
-    setBindings(bindings: pino.Bindings): void;
+        /**
+         * Returns an object containing all the current bindings, cloned from the ones passed in via logger.child().
+         */
+        bindings(): Bindings;
 
-    /**
-     * Flushes the content of the buffer when using pino.destination({ sync: false }).
-     * call the callback when finished
-     */
-    flush(cb?: (err?: Error) => void): void;
-}
+        /**
+         * Adds to the bindings of this logger instance.
+         * Note: Does not overwrite bindings. Can potentially result in duplicate keys in log lines.
+         *
+         * @param bindings: an object of key-value pairs to include in log lines as properties.
+         */
+        setBindings(bindings: Bindings): void;
 
+        /**
+         * Flushes the content of the buffer when using pino.destination({ sync: false }).
+         * call the callback when finished
+         */
+        flush(cb?: (err?: Error) => void): void;
+    }
 
-declare namespace pino {
     //// Exported types and interfaces
-
-    interface BaseLogger {
+    export interface BaseLogger {
         /**
          * Set this property to the desired logging level. In order of priority, available levels are:
          *
@@ -147,7 +149,7 @@ declare namespace pino {
          *
          * You can pass `'silent'` to disable logging.
          */
-        level: pino.LevelWithSilentOrString;
+        level: LevelWithSilentOrString;
 
         /**
          * Log at `'fatal'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
@@ -158,7 +160,7 @@ declare namespace pino {
          * @param msg: the log message to write
          * @param ...args: format string values when `msg` is a format string
          */
-        fatal: pino.LogFn;
+        fatal: LogFn;
         /**
          * Log at `'error'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
          * If more args follows `msg`, these will be used to format `msg` using `util.format`.
@@ -168,7 +170,7 @@ declare namespace pino {
          * @param msg: the log message to write
          * @param ...args: format string values when `msg` is a format string
          */
-        error: pino.LogFn;
+        error: LogFn;
         /**
          * Log at `'warn'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
          * If more args follows `msg`, these will be used to format `msg` using `util.format`.
@@ -178,7 +180,7 @@ declare namespace pino {
          * @param msg: the log message to write
          * @param ...args: format string values when `msg` is a format string
          */
-        warn: pino.LogFn;
+        warn: LogFn;
         /**
          * Log at `'info'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
          * If more args follows `msg`, these will be used to format `msg` using `util.format`.
@@ -188,7 +190,7 @@ declare namespace pino {
          * @param msg: the log message to write
          * @param ...args: format string values when `msg` is a format string
          */
-        info: pino.LogFn;
+        info: LogFn;
         /**
          * Log at `'debug'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
          * If more args follows `msg`, these will be used to format `msg` using `util.format`.
@@ -198,7 +200,7 @@ declare namespace pino {
          * @param msg: the log message to write
          * @param ...args: format string values when `msg` is a format string
          */
-        debug: pino.LogFn;
+        debug: LogFn;
         /**
          * Log at `'trace'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
          * If more args follows `msg`, these will be used to format `msg` using `util.format`.
@@ -208,71 +210,79 @@ declare namespace pino {
          * @param msg: the log message to write
          * @param ...args: format string values when `msg` is a format string
          */
-        trace: pino.LogFn;
+        trace: LogFn;
         /**
          * Noop function.
          */
-        silent: pino.LogFn;
+        silent: LogFn;
+
+        /**
+         * Get `msgPrefix` of the logger instance.
+         *
+         * See {@link https://github.com/pinojs/pino/blob/main/docs/api.md#msgprefix-string}.
+         */
+        get msgPrefix(): string | undefined;
     }
 
-    type Bindings = Record<string, any>;
+    export type Bindings = Record<string, any>;
 
-    type Level = "fatal" | "error" | "warn" | "info" | "debug" | "trace";
-    type LevelOrString = Level | (string & {});
-    type LevelWithSilent = pino.Level | "silent";
-    type LevelWithSilentOrString = LevelWithSilent | (string & {});
+    export type Level = "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+    export type LevelOrString = Level | (string & {});
+    export type LevelWithSilent = Level | "silent";
+    export type LevelWithSilentOrString = LevelWithSilent | (string & {});
 
-    type SerializerFn = (value: any) => any;
-    type WriteFn = (o: object) => void;
+    export type SerializerFn = (value: any) => any;
+    export type WriteFn = (o: object) => void;
 
-    type LevelChangeEventListener<CustomLevels extends string = never> = (
+    export type LevelChangeEventListener<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = (
         lvl: LevelWithSilentOrString,
         val: number,
         prevLvl: LevelWithSilentOrString,
         prevVal: number,
-        logger: Logger<CustomLevels>
+        logger: Logger<CustomLevels, UseOnlyCustomLevels>
     ) => void;
 
-    type LogDescriptor = Record<string, any>;
+    export type LogDescriptor = Record<string, any>;
 
-    type Logger<CustomLevels extends string = never> = BaseLogger & LoggerExtras<CustomLevels> & CustomLevelLogger<CustomLevels>;
+    export type Logger<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = BaseLogger & LoggerExtras<CustomLevels> & CustomLevelLogger<CustomLevels, UseOnlyCustomLevels>;
 
-    type SerializedError = pinoStdSerializers.SerializedError;
-    type SerializedResponse = pinoStdSerializers.SerializedResponse;
-    type SerializedRequest = pinoStdSerializers.SerializedRequest;
+    export type SerializedError = pinoStdSerializers.SerializedError;
+    export type SerializedResponse = pinoStdSerializers.SerializedResponse;
+    export type SerializedRequest = pinoStdSerializers.SerializedRequest;
 
 
-    interface TransportTargetOptions<TransportOptions = Record<string, any>> {
+    export interface TransportTargetOptions<TransportOptions = Record<string, any>> {
         target: string
         options?: TransportOptions
         level?: LevelWithSilentOrString
     }
 
-    interface TransportBaseOptions<TransportOptions = Record<string, any>> {
+    export interface TransportBaseOptions<TransportOptions = Record<string, any>> {
         options?: TransportOptions
         worker?: WorkerOptions & { autoEnd?: boolean}
     }
 
-    interface TransportSingleOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
+    export interface TransportSingleOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
         target: string
     }
 
-    interface TransportPipelineOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
+    export interface TransportPipelineOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
         pipeline: TransportSingleOptions<TransportOptions>[]
+        level?: LevelWithSilentOrString
     }
 
-    interface TransportMultiOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
-        targets: readonly TransportTargetOptions<TransportOptions>[],
+    export interface TransportMultiOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
+        targets: readonly (TransportTargetOptions<TransportOptions>|TransportPipelineOptions<TransportOptions>)[],
         levels?: Record<string, number>
         dedupe?: boolean
     }
 
-    interface MultiStreamOptions {
+    export interface MultiStreamOptions {
         levels?: Record<string, number>
         dedupe?: boolean
     }
 
-    interface DestinationStream {
+    export interface DestinationStream {
         write(msg: string): void;
     }
 
@@ -282,17 +292,17 @@ declare namespace pino {
       lastTime: string;
       lastMsg: string;
       lastObj: object;
-      lastLogger: pino.Logger;
+      lastLogger: Logger;
     }
 
-    type DestinationStreamWithMetadata = DestinationStream & ({ [symbols.needsMetadataGsym]?: false } | DestinationStreamHasMetadata);
+    export type DestinationStreamWithMetadata = DestinationStream & ({ [symbols.needsMetadataGsym]?: false } | DestinationStreamHasMetadata);
 
-    interface StreamEntry<TLevel = Level> {
+    export interface StreamEntry<TLevel = Level> {
         stream: DestinationStream
         level?: TLevel
     }
 
-    interface MultiStreamRes<TOriginLevel = Level> {
+    export interface MultiStreamRes<TOriginLevel = Level> {
         write: (data: any) => void,
         add: <TLevel = Level>(dest: StreamEntry<TLevel> | DestinationStream) => MultiStreamRes<TOriginLevel & TLevel>,
         flushSync: () => void,
@@ -301,7 +311,7 @@ declare namespace pino {
         clone<TLevel = Level>(level: TLevel): MultiStreamRes<TLevel>,
     }
 
-    interface LevelMapping {
+    export interface LevelMapping {
         /**
          * Returns the mappings of level names to their respective internal number representation.
          */
@@ -312,15 +322,36 @@ declare namespace pino {
         labels: { [level: number]: string };
     }
 
-    interface LogFn {
-        // TODO: why is this different from `obj: object` or `obj: any`?
-        /* tslint:disable:no-unnecessary-generics */
-        <T extends object>(obj: T, msg?: string, ...args: any[]): void;
-        (obj: unknown, msg?: string, ...args: any[]): void;
-        (msg: string, ...args: any[]): void;
+    type PlaceholderSpecifier = 'd' | 's' | 'j' | 'o' | 'O';
+    type PlaceholderTypeMapping<T extends PlaceholderSpecifier> = T extends 'd'
+        ? number
+        : T extends 's'
+            ? unknown
+            : T extends 'j' | 'o' | 'O'
+            ? object
+            : never;
+
+    type ParseLogFnArgs<
+        T,
+        Acc extends unknown[] = [],
+    > = T extends `${infer _}%${infer Placeholder}${infer Rest}`
+        ? Placeholder extends PlaceholderSpecifier
+            ? ParseLogFnArgs<Rest, [...Acc, PlaceholderTypeMapping<Placeholder>]>
+            : ParseLogFnArgs<Rest, Acc>
+        : Acc;
+
+    export interface LogFnFields {}
+
+    export interface LogFn {
+        // Simple case: When first argument is always a string message, use parsed arguments directly
+        <TMsg extends string = string>(msg: TMsg, ...args: ParseLogFnArgs<TMsg>): void;
+        // Complex case: When first argument can be any type - if it's a string, no message needed; otherwise require a message
+        <T, TMsg extends string = string>(obj: T extends object ? T & LogFnFields : T, msg?: T extends string ? never: TMsg, ...args: ParseLogFnArgs<TMsg> | []): void;
+        // Complex case with type safety: Same as above but ensures ParseLogFnArgs is a valid tuple before using it
+        <T, TMsg extends string = string>(obj: T extends object ? T & LogFnFields : T, msg?: T extends string ? never : TMsg, ...args: ParseLogFnArgs<TMsg> extends [unknown, ...unknown[]] ? ParseLogFnArgs<TMsg> : unknown[]): void;
     }
 
-    interface LoggerOptions<CustomLevels extends string = never> {
+    export interface LoggerOptions<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> {
         transport?: TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions
         /**
          * Avoid error causes by circular references in the object tree. Default: `true`.
@@ -354,25 +385,27 @@ declare namespace pino {
          * The keys of the object correspond the namespace of the log level, and the values should be the numerical value of the level.
          */
         customLevels?: { [level in CustomLevels]: number };
+
+        /**
+         * Use this option to only use defined `customLevels` and omit Pino's levels.
+         * Logger's default `level` must be changed to a value in `customLevels` in order to use `useOnlyCustomLevels`
+         * Warning: this option may not be supported by downstream transports.
+         */
+        useOnlyCustomLevels?: UseOnlyCustomLevels;
+
         /**
          *  Use this option to define custom comparison of log levels.
          *  Useful to compare custom log levels or non-standard level values.
          *  Default: "ASC"
          */
         levelComparison?: "ASC" | "DESC" | ((current: number, expected: number) => boolean);
-        /**
-         * Use this option to only use defined `customLevels` and omit Pino's levels.
-         * Logger's default `level` must be changed to a value in `customLevels` in order to use `useOnlyCustomLevels`
-         * Warning: this option may not be supported by downstream transports.
-         */
-        useOnlyCustomLevels?: boolean;
 
         /**
          * If provided, the `mixin` function is called each time one of the active logging methods
          * is called. The function must synchronously return an object. The properties of the
          * returned object will be added to the logged JSON.
          */
-        mixin?: MixinFn;
+        mixin?: MixinFn<CustomLevels>;
 
         /**
          * If provided, the `mixinMergeStrategy` function is called each time one of the active
@@ -427,6 +460,27 @@ declare namespace pino {
              * pino.info('hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
              */
             asObject?: boolean;
+            /**
+             * The `asObjectBindingsOnly` option is similar to `asObject` but will keep the message and arguments
+             * unformatted. This allows to defer formatting the message to the actual call to `console` methods,
+             * where browsers then have richer formatting in their devtools than when pino will format the message to
+             * a string first.
+             *
+             * @example
+             * pino.info('hello %s', 'world') // creates and logs {level: 30, time: <ts>}, 'hello %s', 'world'
+             */
+            asObjectBindingsOnly?: boolean;
+            formatters?: {
+                /**
+                 * Changes the shape of the log level.
+                 * The default shape is { level: number }.
+                 */
+                level?: (label: string, number: number) => object;
+                /**
+                 * Changes the shape of the log object.
+                 */
+                log?: (object: Record<string, unknown>) => Record<string, unknown>;
+            }
             /**
              * Instead of passing log messages to `console.log` they can be passed to a supplied function. If `write` is
              * set to a single function, all logging objects are passed to this function. If `write` is an object, it
@@ -621,6 +675,12 @@ declare namespace pino {
              * using apply, like so: method.apply(this, newArgumentsArray).
              */
             logMethod?: (this: Logger, args: Parameters<LogFn>, method: LogFn, level: number) => void;
+
+            /**
+             * Allows for manipulating the stringified JSON log output just before writing to various transports.
+             * This function must return a string and must be valid JSON.
+             */
+            streamWrite?: (s: string) => string;
         };
 
         /**
@@ -644,7 +704,7 @@ declare namespace pino {
         crlf?: boolean;
     }
 
-    interface ChildLoggerOptions<CustomLevels extends string = never> {
+    export interface ChildLoggerOptions<CustomLevels extends string = never> {
         level?: LevelOrString;
         serializers?: { [key: string]: SerializerFn };
         customLevels?: { [level in CustomLevels]: number };
@@ -665,7 +725,7 @@ declare namespace pino {
      * to `messages` and `bindings` in the `logEvent` object. This allows  us to ensure a consistent format for all
      * values between server and client.
      */
-    interface LogEvent {
+    export interface LogEvent {
         /**
          * Unix epoch timestamp in milliseconds, the time is taken from the moment the logger method is called.
          */
@@ -714,7 +774,6 @@ declare namespace pino {
         readonly mixinSym: unique symbol;
         readonly lsCacheSym: unique symbol;
         readonly chindingsSym: unique symbol;
-        readonly parsedChindingsSym: unique symbol;
         readonly asJsonSym: unique symbol;
         readonly writeSym: unique symbol;
         readonly serializersSym: unique symbol;
@@ -765,6 +824,10 @@ declare namespace pino {
             * Returns ISO 8601-formatted time in UTC
             */
         isoTime: TimeFn;
+        /*
+            * Returns RFC 3339-formatted time in UTC
+            */
+        isoTimeNano: TimeFn;
     };
 
     //// Exported functions
@@ -788,6 +851,37 @@ declare namespace pino {
         streamsArray: (DestinationStream | StreamEntry<TLevel>)[] | DestinationStream | StreamEntry<TLevel>,
         opts?: MultiStreamOptions
     ): MultiStreamRes<TLevel>
+
+    //// Nested version of default export for TypeScript/Babel compatibility
+
+    /**
+     * @param [optionsOrStream]: an options object or a writable stream where the logs will be written. It can also receive some log-line metadata, if the
+     * relative protocol is enabled. Default: process.stdout
+     * @returns a new logger instance.
+     */
+    function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(optionsOrStream?: LoggerOptions<CustomLevels, UseOnlyCustomLevels> | DestinationStream): Logger<CustomLevels, UseOnlyCustomLevels>;
+
+    /**
+     * @param [options]: an options object
+     * @param [stream]: a writable stream where the logs will be written. It can also receive some log-line metadata, if the
+     * relative protocol is enabled. Default: process.stdout
+     * @returns a new logger instance.
+     */
+    function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(options: LoggerOptions<CustomLevels, UseOnlyCustomLevels>, stream?: DestinationStream | undefined): Logger<CustomLevels, UseOnlyCustomLevels>;
+
+    /**
+     * Attach selected static members to the nested callable export, so that
+     * `const { pino } = require('pino')` exposes them (e.g. `pino.stdTimeFunctions`).
+     */
+    namespace pino {
+        const stdTimeFunctions: {
+            epochTime: TimeFn;
+            unixTime: TimeFn;
+            nullTime: TimeFn;
+            isoTime: TimeFn;
+            isoTimeNano: TimeFn;
+        };
+    }
 }
 
 //// Callable default export
@@ -797,7 +891,7 @@ declare namespace pino {
  * relative protocol is enabled. Default: process.stdout
  * @returns a new logger instance.
  */
-declare function pino<CustomLevels extends string = never>(optionsOrStream?: LoggerOptions<CustomLevels> | DestinationStream): Logger<CustomLevels>;
+declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(optionsOrStream?: pino.LoggerOptions<CustomLevels, UseOnlyCustomLevels> | pino.DestinationStream): pino.Logger<CustomLevels, UseOnlyCustomLevels>;
 
 /**
  * @param [options]: an options object
@@ -805,59 +899,6 @@ declare function pino<CustomLevels extends string = never>(optionsOrStream?: Log
  * relative protocol is enabled. Default: process.stdout
  * @returns a new logger instance.
  */
-declare function pino<CustomLevels extends string = never>(options: LoggerOptions<CustomLevels>, stream?: DestinationStream | undefined): Logger<CustomLevels>;
-
-
-// Pass through all the top-level exports, allows `import {version} from "pino"`
-// Constants and functions
-export const destination: typeof pino.destination;
-export const transport: typeof pino.transport;
-export const multistream: typeof pino.multistream;
-export const levels: typeof pino.levels;
-export const stdSerializers: typeof pino.stdSerializers;
-export const stdTimeFunctions: typeof pino.stdTimeFunctions;
-export const symbols: typeof pino.symbols;
-export const version: typeof pino.version;
-
-// Types
-export type Bindings = pino.Bindings;
-export type DestinationStreamWithMetadata = pino.DestinationStreamWithMetadata;
-export type Level = pino.Level;
-export type LevelOrString = pino.LevelOrString;
-export type LevelWithSilent = pino.LevelWithSilent;
-export type LevelWithSilentOrString = pino.LevelWithSilentOrString;
-export type LevelChangeEventListener<CustomLevels extends string> = pino.LevelChangeEventListener<CustomLevels>;
-export type LogDescriptor = pino.LogDescriptor;
-export type Logger<CustomLevels extends string = never> = pino.Logger<CustomLevels>;
-export type SerializedError = pino.SerializedError;
-export type SerializerFn = pino.SerializerFn;
-export type SerializedRequest = pino.SerializedRequest;
-export type SerializedResponse = pino.SerializedResponse;
-export type WriteFn = pino.WriteFn;
-
-// Interfaces
-export interface BaseLogger extends pino.BaseLogger {}
-export interface ChildLoggerOptions<CustomLevels extends string = never> extends pino.ChildLoggerOptions<CustomLevels> {}
-export interface DestinationStream extends pino.DestinationStream {}
-export interface LevelMapping extends pino.LevelMapping {}
-export interface LogEvent extends pino.LogEvent {}
-export interface LogFn extends pino.LogFn {}
-export interface LoggerOptions<CustomLevels extends string = never> extends pino.LoggerOptions<CustomLevels> {}
-export interface MultiStreamOptions extends pino.MultiStreamOptions {}
-export interface MultiStreamRes<TLevel = Level> extends pino.MultiStreamRes<TLevel> {}
-export interface StreamEntry<TLevel = Level> extends pino.StreamEntry<TLevel> {}
-export interface TransportBaseOptions extends pino.TransportBaseOptions {}
-export interface TransportMultiOptions extends pino.TransportMultiOptions {}
-export interface TransportPipelineOptions extends pino.TransportPipelineOptions {}
-export interface TransportSingleOptions extends pino.TransportSingleOptions {}
-export interface TransportTargetOptions extends pino.TransportTargetOptions {}
-
-// Bundle all top level exports into a namespace, then export namespace both
-// as default (`import pino from "pino"`) and named variable
-// (`import {pino} from "pino"`).
-export { pino as default, pino };
-// Export just the type side of the namespace as "P", allows
-// `import {P} from "pino"; const log: P.Logger;`.
-// (Legacy support for early 7.x releases, remove in 8.x.)
-    export type { pino as P };
+declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(options: pino.LoggerOptions<CustomLevels, UseOnlyCustomLevels>, stream?: pino.DestinationStream | undefined): pino.Logger<CustomLevels, UseOnlyCustomLevels>;
 
+export = pino;