@types/pino

  • Version 6.3.11
  • Published
  • 40.5 kB
  • 4 dependencies
  • MIT license

Install

npm i @types/pino
yarn add @types/pino
pnpm add @types/pino

Overview

TypeScript definitions for pino

Index

Variables

variable levels

const levels: LevelMapping;

    variable LOG_VERSION

    const LOG_VERSION: number;
    • Holds the current log format version (as output in the v property of each log record).

    variable stdSerializers

    const stdSerializers: {
    req: any;
    res: any;
    err: any;
    mapHttpRequest: any;
    mapHttpResponse: any;
    wrapErrorSerializer: any;
    wrapRequestSerializer: any;
    wrapResponseSerializer: any;
    };
    • Provides functions for serializing objects common to many projects.

    variable stdTimeFunctions

    const stdTimeFunctions: {
    epochTime: TimeFn;
    unixTime: TimeFn;
    nullTime: TimeFn;
    isoTime: TimeFn;
    };
    • Provides functions for generating the timestamp property in the log output. You can set the timestamp option during initialization to one of these functions to adjust the output format. Alternatively, you can specify your own time function. A time function must synchronously return a string that would be a valid component of a JSON string. For example, the default function returns a string like ,"time":1493426328206.

    variable symbols

    const symbols: {
    readonly setLevelSym: unique symbol;
    readonly getLevelSym: unique symbol;
    readonly levelValSym: unique symbol;
    readonly useLevelLabelsSym: unique symbol;
    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;
    readonly redactFmtSym: unique symbol;
    readonly timeSym: unique symbol;
    readonly timeSliceIndexSym: unique symbol;
    readonly streamSym: unique symbol;
    readonly stringifySym: unique symbol;
    readonly stringifiersSym: unique symbol;
    readonly endSym: unique symbol;
    readonly formatOptsSym: unique symbol;
    readonly messageKeySym: unique symbol;
    readonly nestedKeySym: unique symbol;
    readonly wildcardFirstSym: unique symbol;
    readonly needsMetadataGsym: unique symbol;
    readonly useOnlyCustomLevelsSym: unique symbol;
    readonly formattersSym: unique symbol;
    readonly hooksSym: unique symbol;
    };

      variable version

      const version: string;
      • Exposes the Pino package version. Also available on the logger instance.

      Functions

      function destination

      destination: (
      dest?:
      | string
      | number
      | DestinationObjectOptions
      | DestinationStream
      | NodeJS.WritableStream
      ) => any;
      • Create a Pino Destination instance: a stream-like object with significantly more throughput (over 30%) than a standard Node.js stream.

        Parameter dest

        : The destination parameter, at a minimum must be an object with a write method. An ordinary Node.js stream can be passed as the destination (such as the result of fs.createWriteStream) but for peak log writing performance it is strongly recommended to use pino.destination to create the destination stream.

        Returns

        A Sonic-Boom stream to be used as destination for the pino function

      function extreme

      extreme: (fileDescriptor?: string | number) => any;
      • Create an extreme mode destination. This yields an additional 60% performance boost. There are trade-offs that should be understood before usage.

        Parameter fileDescriptor

        : File path or numerical file descriptor, by default 1

        Returns

        A Sonic-Boom stream to be used as destination for the pino function

      function final

      final: {
      (
      logger: Logger,
      handler: (error: Error, finalLogger: Logger, ...args: any[]) => void
      ): (error: Error | null, ...args: any[]) => void;
      (logger: Logger): Logger;
      };
      • The pino.final method can be used to create an exit listener function. This listener function can be supplied to process exit events. The exit listener function will call the handler with

        Parameter logger

        : pino logger that serves as reference for the final logger

        Parameter handler

        : Function that will be called by the handler returned from this function

        Returns

        Exit listener function that can be supplied to process exit events and will call the supplied handler function

      • The pino.final method can be used to acquire a final logger instance that synchronously flushes on every write.

        Parameter logger

        : pino logger that serves as reference for the final logger

        Returns

        Final, synchronous logger

      function P

      P: typeof P;
      • Parameter 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.

      • Parameter options

        : an options object

        Parameter 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.

      Interfaces

      interface BaseLogger

      interface BaseLogger extends EventEmitter {}

        property customLevels

        customLevels: { [key: string]: number };
        • Define additional logging levels.

        property debug

        debug: 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.

          Parameter obj

          : object to be serialized

          Parameter msg

          : the log message to write

          Parameter

          ...args: format string values when msg is a format string

        property error

        error: 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.

          Parameter obj

          : object to be serialized

          Parameter msg

          : the log message to write

          Parameter

          ...args: format string values when msg is a format string

        property fatal

        fatal: LogFn;
        • Log at 'fatal' 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.

          Parameter obj

          : object to be serialized

          Parameter msg

          : the log message to write

          Parameter

          ...args: format string values when msg is a format string

        property info

        info: 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.

          Parameter obj

          : object to be serialized

          Parameter msg

          : the log message to write

          Parameter

          ...args: format string values when msg is a format string

        property level

        level: LevelWithSilent | string;
        • Set this property to the desired logging level. In order of priority, available levels are:

          - 'fatal' - 'error' - 'warn' - 'info' - 'debug' - 'trace'

          The logging level is a __minimum__ level. For instance if logger.level is 'info' then all 'fatal', 'error', 'warn', and 'info' logs will be enabled.

          You can pass 'silent' to disable logging.

        property levels

        levels: LevelMapping;

          property levelVal

          levelVal: number;
          • Returns the integer value for the logger instance's logging level.

          property LOG_VERSION

          readonly LOG_VERSION: number;
          • Holds the current log format version (as output in the v property of each log record).

          property pino

          readonly pino: string;
          • Exposes the current version of Pino.

          property silent

          silent: LogFn;
          • Noop function.

          property trace

          trace: 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.

            Parameter obj

            : object to be serialized

            Parameter msg

            : the log message to write

            Parameter

            ...args: format string values when msg is a format string

          property useLevelLabels

          useLevelLabels: boolean;
          • Outputs the level as a string instead of integer.

          property useOnlyCustomLevels

          useOnlyCustomLevels: boolean;
          • Use only defined customLevels and omit Pino's levels.

          property version

          readonly version: string;
          • Exposes the Pino package version. Also available on the exported pino function.

          property warn

          warn: 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.

            Parameter obj

            : object to be serialized

            Parameter msg

            : the log message to write

            Parameter

            ...args: format string values when msg is a format string

          method addListener

          addListener: (event: 'level-change', listener: LevelChangeEventListener) => this;

            method bindings

            bindings: () => Bindings;
            • Returns an object containing all the current bindings, cloned from the ones passed in via logger.child().

            method child

            child: (bindings: Bindings) => Logger;
            • 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.

              Parameter bindings

              : an object of key-value pairs to include in log lines as properties.

              Returns

              a child logger instance.

            method flush

            flush: () => void;
            • Flushes the content of the buffer in extreme mode. It has no effect if extreme mode is not enabled.

            method isLevelEnabled

            isLevelEnabled: (level: LevelWithSilent | string) => boolean;
            • A utility method for determining if a given log level will write to the destination.

            method on

            on: (event: 'level-change', listener: LevelChangeEventListener) => this;
            • 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.

              Parameter event

              : only ever fires the 'level-change' event

              Parameter listener

              : The listener is passed four arguments: levelLabel, levelValue, previousLevelLabel, previousLevelValue.

            method once

            once: (event: 'level-change', listener: LevelChangeEventListener) => this;

              method prependListener

              prependListener: (
              event: 'level-change',
              listener: LevelChangeEventListener
              ) => this;

                method prependOnceListener

                prependOnceListener: (
                event: 'level-change',
                listener: LevelChangeEventListener
                ) => this;

                  method removeListener

                  removeListener: (
                  event: 'level-change',
                  listener: LevelChangeEventListener
                  ) => this;

                    interface Bindings

                    interface Bindings {}

                      property level

                      level?: Level | string | undefined;

                        property serializers

                        serializers?: { [key: string]: SerializerFn } | undefined;

                          index signature

                          [key: string]: any;

                            interface DestinationObjectOptions

                            interface DestinationObjectOptions {}
                            • Equivalent of SonicBoom constructor options object

                            property dest

                            dest?: string | undefined;

                              property fd

                              fd?: string | number | undefined;

                                property minLength

                                minLength?: number | undefined;

                                  property sync

                                  sync?: boolean | undefined;

                                    interface DestinationStream

                                    interface DestinationStream {}

                                      method write

                                      write: (msg: string) => void;

                                        interface LevelMapping

                                        interface LevelMapping {}

                                          property labels

                                          labels: { [level: number]: string };
                                          • Returns the mappings of level internal level numbers to their string representations.

                                          property values

                                          values: { [level: string]: number };
                                          • Returns the mappings of level names to their respective internal number representation.

                                          interface LogEvent

                                          interface LogEvent {}
                                          • A data structure representing a log message, it represents the arguments passed to a logger statement, the level at which they were logged and the hierarchy of child bindings.

                                            By default serializers are not applied to log output in the browser, but they will always be applied to messages and bindings in the logEvent object. This allows us to ensure a consistent format for all values between server and client.

                                          property bindings

                                          bindings: Bindings[];
                                          • Represents each child logger (if any), and the relevant bindings.

                                            For instance, given logger.child({a: 1}).child({b: 2}).info({c: 3}), the bindings array would hold [{a: 1}, {b: 2}] and the messages array would be [{c: 3}]. The bindings are ordered according to their position in the child logger hierarchy, with the lowest index being the top of the hierarchy.

                                          property level

                                          level: {
                                          label: string;
                                          value: number;
                                          };
                                          • Holds the label (for instance info), and the corresponding numerical value (for instance 30). This could be important in cases where client side level values and labels differ from server side.

                                          property messages

                                          messages: any[];
                                          • All arguments passed to logger method, (for instance logger.info('a', 'b', 'c') would result in messages array ['a', 'b', 'c']).

                                          property ts

                                          ts: number;
                                          • Unix epoch timestamp in milliseconds, the time is taken from the moment the logger method is called.

                                          interface LogFn

                                          interface LogFn {}

                                            call signature

                                            <T extends object>(obj: T, msg?: string, ...args: any[]): void;

                                              call signature

                                              (msg: string, ...args: any[]): void;

                                                interface LoggerOptions

                                                interface LoggerOptions {}

                                                  property base

                                                  base?: { [key: string]: any } | null | undefined;
                                                  • key-value object added as child logger to each log line. If set to null the base child logger is not added

                                                  property browser

                                                  browser?:
                                                  | {
                                                  /**
                                                  * The `asObject` option will create a pino-like log object instead of passing all arguments to a console
                                                  * method. When `write` is set, `asObject` will always be true.
                                                  *
                                                  * @example
                                                  * pino.info('hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
                                                  */
                                                  asObject?: boolean | undefined;
                                                  /**
                                                  * 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
                                                  * can have methods that correspond to the levels. When a message is logged at a given level, the
                                                  * corresponding method is called. If a method isn't present, the logging falls back to using the `console`.
                                                  *
                                                  * @example
                                                  * const pino = require('pino')({
                                                  * browser: {
                                                  * write: (o) => {
                                                  * // do something with o
                                                  * }
                                                  * }
                                                  * })
                                                  *
                                                  * @example
                                                  * const pino = require('pino')({
                                                  * browser: {
                                                  * write: {
                                                  * info: function (o) {
                                                  * //process info log object
                                                  * },
                                                  * error: function (o) {
                                                  * //process error log object
                                                  * }
                                                  * }
                                                  * }
                                                  * })
                                                  */
                                                  write?:
                                                  | WriteFn
                                                  | ({
                                                  fatal?: WriteFn | undefined;
                                                  error?: WriteFn | undefined;
                                                  warn?: WriteFn | undefined;
                                                  info?: WriteFn | undefined;
                                                  debug?: WriteFn | undefined;
                                                  trace?: WriteFn | undefined;
                                                  } & { [logLevel: string]: WriteFn })
                                                  | undefined;
                                                  /**
                                                  * The serializers provided to `pino` are ignored by default in the browser, including the standard
                                                  * serializers provided with Pino. Since the default destination for log messages is the console, values
                                                  * such as `Error` objects are enhanced for inspection, which they otherwise wouldn't be if the Error
                                                  * serializer was enabled. We can turn all serializers on or we can selectively enable them via an array.
                                                  *
                                                  * When `serialize` is `true` the standard error serializer is also enabled (see
                                                  * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#pino-stdserializers}). This is a global
                                                  * serializer which will apply to any `Error` objects passed to the logger methods.
                                                  *
                                                  * If `serialize` is an array the standard error serializer is also automatically enabled, it can be
                                                  * explicitly disabled by including a string in the serialize array: `!stdSerializers.err` (see example).
                                                  *
                                                  * The `serialize` array also applies to any child logger serializers (see
                                                  * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#bindingsserializers-object} for how to
                                                  * set child-bound serializers).
                                                  *
                                                  * Unlike server pino the serializers apply to every object passed to the logger method, if the `asObject`
                                                  * option is `true`, this results in the serializers applying to the first object (as in server pino).
                                                  *
                                                  * For more info on serializers see
                                                  * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#serializers-object}.
                                                  *
                                                  * @example
                                                  * const pino = require('pino')({
                                                  * browser: {
                                                  * serialize: true
                                                  * }
                                                  * })
                                                  *
                                                  * @example
                                                  * const pino = require('pino')({
                                                  * serializers: {
                                                  * custom: myCustomSerializer,
                                                  * another: anotherSerializer
                                                  * },
                                                  * browser: {
                                                  * serialize: ['custom']
                                                  * }
                                                  * })
                                                  * // following will apply myCustomSerializer to the custom property,
                                                  * // but will not apply anotherSerializer to another key
                                                  * pino.info({custom: 'a', another: 'b'})
                                                  *
                                                  * @example
                                                  * const pino = require('pino')({
                                                  * serializers: {
                                                  * custom: myCustomSerializer,
                                                  * another: anotherSerializer
                                                  * },
                                                  * browser: {
                                                  * serialize: ['!stdSerializers.err', 'custom'] //will not serialize Errors, will serialize `custom` keys
                                                  * }
                                                  * })
                                                  */
                                                  serialize?: boolean | string[] | undefined;
                                                  /**
                                                  * Options for transmission of logs.
                                                  *
                                                  * @example
                                                  * const pino = require('pino')({
                                                  * browser: {
                                                  * transmit: {
                                                  * level: 'warn',
                                                  * send: function (level, logEvent) {
                                                  * if (level === 'warn') {
                                                  * // maybe send the logEvent to a separate endpoint
                                                  * // or maybe analyse the messages further before sending
                                                  * }
                                                  * // we could also use the `logEvent.level.value` property to determine
                                                  * // numerical value
                                                  * if (logEvent.level.value >= 50) { // covers error and fatal
                                                  *
                                                  * // send the logEvent somewhere
                                                  * }
                                                  * }
                                                  * }
                                                  * }
                                                  * })
                                                  */
                                                  transmit?:
                                                  | {
                                                  /**
                                                  * Specifies the minimum level (inclusive) of when the `send` function should be called, if not supplied
                                                  * the `send` function will be called based on the main logging `level` (set via `options.level`,
                                                  * defaulting to `info`).
                                                  */
                                                  level?: Level | string | undefined;
                                                  /**
                                                  * Remotely record log messages.
                                                  *
                                                  * @description Called after writing the log message.
                                                  */
                                                  send: (level: Level, logEvent: LogEvent) => void;
                                                  }
                                                  | undefined;
                                                  }
                                                  | undefined;
                                                  • Browser only, see http://getpino.io/#/docs/browser.

                                                  property changeLevelName

                                                  changeLevelName?: string | undefined;
                                                  • (DEPRECATED, use levelKey) Changes the property level to any string value you pass in. Default: 'level'

                                                  property customLevels

                                                  customLevels?: { [key: string]: number } | undefined;
                                                  • Use this option to define additional logging levels. The keys of the object correspond the namespace of the log level, and the values should be the numerical value of the level.

                                                  property enabled

                                                  enabled?: boolean | undefined;
                                                  • Enables logging. Default: true.

                                                  property formatters

                                                  formatters?:
                                                  | {
                                                  /**
                                                  * Changes the shape of the log level.
                                                  * The default shape is { level: number }.
                                                  * The function takes two arguments, the label of the level (e.g. 'info') and the numeric value (e.g. 30).
                                                  */
                                                  level?: ((label: string, number: number) => object) | undefined;
                                                  /**
                                                  * Changes the shape of the bindings.
                                                  * The default shape is { pid, hostname }.
                                                  * The function takes a single argument, the bindings object.
                                                  * It will be called every time a child logger is created.
                                                  */
                                                  bindings?: ((bindings: Bindings) => object) | undefined;
                                                  /**
                                                  * Changes the shape of the log object.
                                                  * This function will be called every time one of the log methods (such as .info) is called.
                                                  * All arguments passed to the log method, except the message, will be pass to this function.
                                                  * By default it does not change the shape of the log object.
                                                  */
                                                  log?: ((object: Record<string, unknown>) => object) | undefined;
                                                  }
                                                  | undefined;
                                                  • An object containing functions for formatting the shape of the log lines. These functions should return a JSONifiable object and should never throw. These functions allow for full customization of the resulting log lines. For example, they can be used to change the level key name or to enrich the default metadata.

                                                  property hooks

                                                  hooks?:
                                                  | {
                                                  /**
                                                  * Allows for manipulating the parameters passed to logger methods. The signature for this hook is
                                                  * logMethod (args, method, level) {}, where args is an array of the arguments that were passed to the
                                                  * log method and method is the log method itself, and level is the log level. This hook must invoke the method function by
                                                  * using apply, like so: method.apply(this, newArgumentsArray).
                                                  */
                                                  logMethod?:
                                                  | ((args: any[], method: LogFn, level: number) => void)
                                                  | undefined;
                                                  }
                                                  | undefined;
                                                  • An object mapping to hook functions. Hook functions allow for customizing internal logger operations. Hook functions must be synchronous functions.

                                                  property level

                                                  level?: LevelWithSilent | string | undefined;
                                                  • One of the supported levels or silent to disable logging. Any other value defines a custom level and requires supplying a level value via levelVal. Default: 'info'.

                                                  property levelKey

                                                  levelKey?: string | undefined;
                                                  • Changes the property level to any string value you pass in. Default: 'level'

                                                  property levelVal

                                                  levelVal?: number | undefined;
                                                  • When defining a custom log level via level, set to an integer value to define the new level. Default: undefined.

                                                  property messageKey

                                                  messageKey?: string | undefined;
                                                  • The string key for the 'message' in the JSON object. Default: "msg".

                                                  property mixin

                                                  mixin?: MixinFn | undefined;
                                                  • 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.

                                                  property name

                                                  name?: string | undefined;
                                                  • The name of the logger. Default: undefined.

                                                  property nestedKey

                                                  nestedKey?: string | undefined;
                                                  • The string key to place any logged object under.

                                                  property prettifier

                                                  prettifier?: any;
                                                  • Allows to optionally define which prettifier module to use.

                                                  property prettyPrint

                                                  prettyPrint?: boolean | PrettyOptions | undefined;
                                                  • Enables pino.pretty. This is intended for non-production configurations. This may be set to a configuration object as outlined in http://getpino.io/#/docs/API?id=pretty. Default: false.

                                                  property redact

                                                  redact?: string[] | redactOptions | undefined;
                                                  • As an array, the redact option specifies paths that should have their values redacted from any log output.

                                                    Each path must be a string using a syntax which corresponds to JavaScript dot and bracket notation.

                                                    If an object is supplied, three options can be specified:

                                                    paths (String[]): Required. An array of paths censor (String): Optional. A value to overwrite key which are to be redacted. Default: '[Redacted]' remove (Boolean): Optional. Instead of censoring the value, remove both the key and the value. Default: false

                                                  property safe

                                                  safe?: boolean | undefined;
                                                  • Avoid error causes by circular references in the object tree. Default: true.

                                                  property serializers

                                                  serializers?: { [key: string]: SerializerFn } | undefined;
                                                  • an object containing functions for custom serialization of objects. These functions should return an JSONifiable object and they should never throw. When logging an object, each top-level property matching the exact key of a serializer will be serialized using the defined serializer.

                                                  property timestamp

                                                  timestamp?: TimeFn | boolean | undefined;
                                                  • Enables or disables the inclusion of a timestamp in the log message. If a function is supplied, it must synchronously return a JSON string representation of the time. If set to false, no timestamp will be included in the output. See stdTimeFunctions for a set of available functions for passing in as a value for this option. Caution: any sort of formatted time will significantly slow down Pino's performance.

                                                  property useLevelLabels

                                                  useLevelLabels?: boolean | undefined;
                                                  • Outputs the level as a string instead of integer. Default: false.

                                                  property useOnlyCustomLevels

                                                  useOnlyCustomLevels?: boolean | undefined;
                                                  • 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.

                                                  method onTerminated

                                                  onTerminated: (eventName: string, err: any) => void;
                                                  • This function will be invoked during process shutdown when extreme is set to true. If you do not specify a function, Pino will invoke process.exit(0) when no error has occurred, and process.exit(1) otherwise. If you do specify a function, it is up to you to terminate the process; you must perform only synchronous operations at this point. See http://getpino.io/#/docs/extreme for more detail.

                                                  interface redactOptions

                                                  interface redactOptions {}

                                                    property censor

                                                    censor?: string | ((v: any) => any) | undefined;

                                                      property paths

                                                      paths: string[];

                                                        property remove

                                                        remove?: boolean | undefined;

                                                          Type Aliases

                                                          type Level

                                                          type Level = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';

                                                            type LevelChangeEventListener

                                                            type LevelChangeEventListener = (
                                                            lvl: LevelWithSilent | string,
                                                            val: number,
                                                            prevLvl: LevelWithSilent | string,
                                                            prevVal: number
                                                            ) => void;

                                                              type LevelWithSilent

                                                              type LevelWithSilent = Level | 'silent';

                                                                type LogDescriptor

                                                                type LogDescriptor = Record<string, any>;
                                                                • Describes a log line.

                                                                type Logger

                                                                type Logger = BaseLogger & { [key: string]: LogFn };

                                                                  type MixinFn

                                                                  type MixinFn = () => object;

                                                                    type PrettyOptions

                                                                    type PrettyOptions = PinoPretty.PrettyOptions & {
                                                                    /**
                                                                    * Suppress warning on first synchronous flushing.
                                                                    */
                                                                    suppressFlushSyncWarning?: boolean | undefined;
                                                                    };

                                                                      type SerializedError

                                                                      type SerializedError = pinoStdSerializers.SerializedError;

                                                                        type SerializedRequest

                                                                        type SerializedRequest = pinoStdSerializers.SerializedRequest;

                                                                          type SerializedResponse

                                                                          type SerializedResponse = pinoStdSerializers.SerializedResponse;

                                                                            type SerializerFn

                                                                            type SerializerFn = (value: any) => any;

                                                                              type TimeFn

                                                                              type TimeFn = () => string;

                                                                                type WriteFn

                                                                                type WriteFn = (o: object) => void;

                                                                                  Package Files (1)

                                                                                  Dependencies (4)

                                                                                  Dev Dependencies (0)

                                                                                  No dev dependencies.

                                                                                  Peer Dependencies (0)

                                                                                  No peer dependencies.

                                                                                  Badge

                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/pino.

                                                                                  • Markdown
                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/pino)
                                                                                  • HTML
                                                                                    <a href="https://www.jsdocs.io/package/@types/pino"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>