@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/pino/pino.d.ts

@@ -13,131 +13,124 @@
 //                 Michel Nemnom <https://github.com/Pegase745>
 //                 Igor Savin <https://github.com/kibertoad>
 //                 James Bromwell <https://github.com/thw0rted>
-// TypeScript Version: 4.4
 
 import type { EventEmitter } from "events";
 import * as pinoStdSerializers from "pino-std-serializers";
 import type { SonicBoom, SonicBoomOpts } from "sonic-boom";
+import ThreadStream from "thread-stream";
 import type { WorkerOptions } from "worker_threads";
 
+declare namespace pino {
+    //// Non-exported types and interfaces
 
+    type TimeFn = () => string;
+    type MixinFn<CustomLevels extends string = never> = (mergeObject: object, level: number, logger:Logger<CustomLevels>) => object;
+    type MixinMergeStrategyFn = (mergeObject: object, mixinObject: object) => object;
 
-//// Non-exported types and interfaces
-
-// ToDo https://github.com/pinojs/thread-stream/issues/24
-type ThreadStream = any
-
-type TimeFn = () => string;
-type MixinFn<CustomLevels extends string = never> = (mergeObject: object, level: number, logger:pino.Logger<CustomLevels>) => object;
-type MixinMergeStrategyFn = (mergeObject: object, mixinObject: object) => object;
-
-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<pino.Level, CustomLevels>]: UseOnlyCustomLevels extends true ? never : pino.LogFn;
- } & {
-    [level in CustomLevels]: pino.LogFn;
- };
-
-/**
-* 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, UseOnlyCustomLevels extends boolean = boolean> 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;
-    /**
-     * 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, UseOnlyCustomLevels>): this;
-    addListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    once(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    prependListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    prependOnceListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    removeListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): 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:
          *
@@ -153,7 +146,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.
@@ -164,7 +157,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`.
@@ -174,7 +167,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`.
@@ -184,7 +177,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`.
@@ -194,7 +187,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`.
@@ -204,7 +197,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`.
@@ -214,24 +207,31 @@ 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, UseOnlyCustomLevels extends boolean = boolean> = (
+    export type LevelChangeEventListener<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = (
         lvl: LevelWithSilentOrString,
         val: number,
         prevLvl: LevelWithSilentOrString,
@@ -239,47 +239,47 @@ declare namespace pino {
         logger: Logger<CustomLevels, UseOnlyCustomLevels>
     ) => void;
 
-    type LogDescriptor = Record<string, any>;
+    export type LogDescriptor = Record<string, any>;
 
-    type Logger<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = BaseLogger & LoggerExtras<CustomLevels> & CustomLevelLogger<CustomLevels, UseOnlyCustomLevels>;
+    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>{
+    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;
     }
 
@@ -289,26 +289,26 @@ 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,
         minLevel: number,
         streams: StreamEntry<TOriginLevel>[],
-        clone<TLevel = Level>(level: TLevel): MultiStreamRes<TLevel>,
+        clone<const TLevel = Level>(level: TLevel): MultiStreamRes<TLevel>,
     }
 
-    interface LevelMapping {
+    export interface LevelMapping {
         /**
          * Returns the mappings of level names to their respective internal number representation.
          */
@@ -319,15 +319,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'
+            ? {} | null
+            : 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, UseOnlyCustomLevels extends boolean = boolean> {
+    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`.
@@ -436,6 +457,16 @@ 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.
@@ -447,6 +478,13 @@ declare namespace pino {
                  */
                 log?: (object: Record<string, unknown>) => Record<string, unknown>;
             }
+            /**
+             * When true, attempts to capture and include the caller location (file:line:column).
+             * In object mode, adds a `caller` string property to the logged object.
+             * Otherwise, appends the caller string as an extra console argument.
+             * This is a browser-only, best-effort feature.
+             */
+            reportCaller?: boolean;
             /**
              * 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
@@ -641,6 +679,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;
         };
 
         /**
@@ -664,7 +708,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 };
@@ -685,7 +729,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.
          */
@@ -734,7 +778,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;
@@ -785,6 +828,10 @@ declare namespace pino {
             * Returns ISO 8601-formatted time in UTC
             */
         isoTime: TimeFn;
+        /*
+            * Returns RFC 3339-formatted time in UTC
+            */
+        isoTimeNano: TimeFn;
     };
 
     //// Exported functions
@@ -808,6 +855,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
@@ -817,7 +895,7 @@ declare namespace pino {
  * relative protocol is enabled. Default: process.stdout
  * @returns a new logger instance.
  */
-declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(optionsOrStream?: LoggerOptions<CustomLevels, UseOnlyCustomLevels> | DestinationStream): Logger<CustomLevels, UseOnlyCustomLevels>;
+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
@@ -825,59 +903,6 @@ declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels e
  * relative protocol is enabled. Default: process.stdout
  * @returns a new logger instance.
  */
-declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(options: LoggerOptions<CustomLevels, UseOnlyCustomLevels>, stream?: DestinationStream | undefined): Logger<CustomLevels, UseOnlyCustomLevels>;
-
-
-// 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, UseOnlyCustomLevels extends boolean = boolean> = pino.Logger<CustomLevels, UseOnlyCustomLevels>;
-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, UseOnlyCustomLevels extends boolean = boolean> extends pino.LoggerOptions<CustomLevels, UseOnlyCustomLevels> {}
-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;

package/node_modules/pino/pino.js

@@ -70,7 +70,8 @@ const defaultOptions = {
     }
   }),
   hooks: {
-    logMethod: undefined
+    logMethod: undefined,
+    streamWrite: undefined
   },
   timestamp: epochTime,
   name: undefined,