@m5kdev/frontend 0.8.2 → 0.8.3

package/dist/node_modules/.pnpm/pino@9.6.0/node_modules/pino/pino.d.ts

@@ -1,766 +0,0 @@
-import { SerializedError, SerializedRequest, SerializedResponse, index_d_exports } from "../../../pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js";
-import { SonicBoom, SonicBoomOpts } from "../../../sonic-boom@4.2.0/node_modules/sonic-boom/types/index.js";
-import { EventEmitter } from "events";
-import { WorkerOptions } from "worker_threads";
-
-//#region ../../node_modules/.pnpm/pino@9.6.0/node_modules/pino/pino.d.ts
-//// 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;
-interface redactOptions {
-  paths: string[];
-  censor?: string | ((value: any, path: string[]) => any);
-  remove?: boolean;
-}
-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;
-  levels: pino.LevelMapping;
-  /**
-   * Outputs the level as a string instead of integer.
-   */
-  useLevelLabels: boolean;
-  /**
-   * Returns the integer value for the logger instance's logging level.
-   */
-  levelVal: number;
-  /**
-   * 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>;
-  /**
-   * This can be used to modify the callback function on creation of a new child.
-   */
-  onChild: OnChildCallback<CustomLevels>;
-  /**
-   * 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;
-  /**
-   * A utility method for determining if a given log level will write to the destination.
-   */
-  isLevelEnabled(level: pino.LevelWithSilentOrString): boolean;
-  /**
-   * Returns an object containing all the current bindings, cloned from the ones passed in via logger.child().
-   */
-  bindings(): pino.Bindings;
-  /**
-   * 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;
-  /**
-   * 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 {
-    /**
-     * 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.
-     */
-    level: pino.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.
-     * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-     *
-     * @typeParam T: the interface of the object being serialized. Default is object.
-     * @param obj: object to be serialized
-     * @param msg: the log message to write
-     * @param ...args: format string values when `msg` is a format string
-     */
-    fatal: pino.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`.
-     *
-     * @typeParam T: the interface of the object being serialized. Default is object.
-     * @param obj: object to be serialized
-     * @param msg: the log message to write
-     * @param ...args: format string values when `msg` is a format string
-     */
-    error: pino.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`.
-     *
-     * @typeParam T: the interface of the object being serialized. Default is object.
-     * @param obj: object to be serialized
-     * @param msg: the log message to write
-     * @param ...args: format string values when `msg` is a format string
-     */
-    warn: pino.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`.
-     *
-     * @typeParam T: the interface of the object being serialized. Default is object.
-     * @param obj: object to be serialized
-     * @param msg: the log message to write
-     * @param ...args: format string values when `msg` is a format string
-     */
-    info: pino.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`.
-     *
-     * @typeParam T: the interface of the object being serialized. Default is object.
-     * @param obj: object to be serialized
-     * @param msg: the log message to write
-     * @param ...args: format string values when `msg` is a format string
-     */
-    debug: pino.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`.
-     *
-     * @typeParam T: the interface of the object being serialized. Default is object.
-     * @param obj: object to be serialized
-     * @param msg: the log message to write
-     * @param ...args: format string values when `msg` is a format string
-     */
-    trace: pino.LogFn;
-    /**
-     * Noop function.
-     */
-    silent: pino.LogFn;
-  }
-  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 & {});
-  type SerializerFn = (value: any) => any;
-  type WriteFn = (o: object) => void;
-  type LevelChangeEventListener<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = (lvl: LevelWithSilentOrString, val: number, prevLvl: LevelWithSilentOrString, prevVal: number, logger: Logger<CustomLevels, UseOnlyCustomLevels>) => void;
-  type LogDescriptor = Record<string, any>;
-  type Logger<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = BaseLogger & LoggerExtras<CustomLevels> & CustomLevelLogger<CustomLevels, UseOnlyCustomLevels>;
-  type SerializedError = SerializedError;
-  type SerializedResponse = SerializedResponse;
-  type SerializedRequest = SerializedRequest;
-  interface TransportTargetOptions<TransportOptions = Record<string, any>> {
-    target: string;
-    options?: TransportOptions;
-    level?: LevelWithSilentOrString;
-  }
-  interface TransportBaseOptions<TransportOptions = Record<string, any>> {
-    options?: TransportOptions;
-    worker?: WorkerOptions & {
-      autoEnd?: boolean;
-    };
-  }
-  interface TransportSingleOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions> {
-    target: string;
-  }
-  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> | TransportPipelineOptions<TransportOptions>)[];
-    levels?: Record<string, number>;
-    dedupe?: boolean;
-  }
-  interface MultiStreamOptions {
-    levels?: Record<string, number>;
-    dedupe?: boolean;
-  }
-  interface DestinationStream {
-    write(msg: string): void;
-  }
-  interface DestinationStreamHasMetadata {
-    [symbols.needsMetadataGsym]: true;
-    lastLevel: number;
-    lastTime: string;
-    lastMsg: string;
-    lastObj: object;
-    lastLogger: pino.Logger;
-  }
-  type DestinationStreamWithMetadata = DestinationStream & ({
-    [symbols.needsMetadataGsym]?: false;
-  } | DestinationStreamHasMetadata);
-  interface StreamEntry<TLevel = Level> {
-    stream: DestinationStream;
-    level?: TLevel;
-  }
-  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>;
-  }
-  interface LevelMapping {
-    /**
-     * Returns the mappings of level names to their respective internal number representation.
-     */
-    values: {
-      [level: string]: number;
-    };
-    /**
-     * Returns the mappings of level internal level numbers to their string representations.
-     */
-    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;
-  }
-  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`.
-     */
-    safe?: boolean;
-    /**
-     * The name of the logger. Default: `undefined`.
-     */
-    name?: string;
-    /**
-     * 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.
-     */
-    serializers?: {
-      [key: string]: SerializerFn;
-    };
-    /**
-     * 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.
-     */
-    timestamp?: TimeFn | boolean;
-    /**
-     * 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'.
-     */
-    level?: LevelWithSilentOrString;
-    /**
-     * 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.
-     */
-    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);
-    /**
-     * 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<CustomLevels>;
-    /**
-     * If provided, the `mixinMergeStrategy` function is called each time one of the active
-     * logging methods is called. The first parameter is the value `mergeObject` or an empty object,
-     * the second parameter is the value resulting from `mixin()` or an empty object.
-     * The function must synchronously return an object.
-     */
-    mixinMergeStrategy?: MixinMergeStrategyFn;
-    /**
-     * 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
-     */
-    redact?: string[] | redactOptions;
-    /**
-     * When defining a custom log level via level, set to an integer value to define the new level. Default: `undefined`.
-     */
-    levelVal?: number;
-    /**
-     * The string key for the 'message' in the JSON object. Default: "msg".
-     */
-    messageKey?: string;
-    /**
-     * The string key for the 'error' in the JSON object. Default: "err".
-     */
-    errorKey?: string;
-    /**
-     * The string key to place any logged object under.
-     */
-    nestedKey?: string;
-    /**
-     * Enables logging. Default: `true`.
-     */
-    enabled?: boolean;
-    /**
-     * Browser only, see http://getpino.io/#/docs/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;
-      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
-       * 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;
-        error?: WriteFn;
-        warn?: WriteFn;
-        info?: WriteFn;
-        debug?: WriteFn;
-        trace?: WriteFn;
-      } & {
-        [logLevel: string]: WriteFn;
-      });
-      /**
-       * 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[];
-      /**
-       * 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?: LevelOrString;
-        /**
-         * Remotely record log messages.
-         *
-         * @description Called after writing the log message.
-         */
-        send: (level: Level, logEvent: LogEvent) => void;
-      };
-      /**
-       * The disabled option will disable logging in browser if set to true, by default it is set to false.
-       *
-       * @example
-       * const pino = require('pino')({browser: {disabled: true}})
-       */
-      disabled?: boolean;
-    };
-    /**
-     * key-value object added as child logger to each log line. If set to null the base child logger is not added
-     */
-    base?: {
-      [key: string]: any;
-    } | null;
-    /**
-     * 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.
-     */
-    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;
-      /**
-       * 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;
-      /**
-       * 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>) => Record<string, unknown>;
-    };
-    /**
-     * A string that would be prefixed to every message (and child message)
-     */
-    msgPrefix?: string;
-    /**
-     * An object mapping to hook functions. Hook functions allow for customizing internal logger operations.
-     * Hook functions must be synchronous functions.
-     */
-    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?: (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;
-    };
-    /**
-     * Stringification limit at a specific nesting depth when logging circular object. Default: `5`.
-     */
-    depthLimit?: number;
-    /**
-     * Stringification limit of properties/elements when logging a specific object/array with circular references. Default: `100`.
-     */
-    edgeLimit?: number;
-    /**
-     * Optional child creation callback.
-     */
-    onChild?: OnChildCallback<CustomLevels>;
-    /**
-     * logs newline delimited JSON with `\r\n` instead of `\n`. Default: `false`.
-     */
-    crlf?: boolean;
-  }
-  interface ChildLoggerOptions<CustomLevels extends string = never> {
-    level?: LevelOrString;
-    serializers?: {
-      [key: string]: SerializerFn;
-    };
-    customLevels?: { [level in CustomLevels]: number };
-    formatters?: {
-      level?: (label: string, number: number) => object;
-      bindings?: (bindings: Bindings) => object;
-      log?: (object: object) => object;
-    };
-    redact?: string[] | redactOptions;
-    msgPrefix?: string;
-  }
-  /**
-   * 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.
-   *
-   * @description 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.
-   */
-  interface LogEvent {
-    /**
-     * Unix epoch timestamp in milliseconds, the time is taken from the moment the logger method is called.
-     */
-    ts: number;
-    /**
-     * All arguments passed to logger method, (for instance `logger.info('a', 'b', 'c')` would result in `messages`
-     * array `['a', 'b', 'c']`).
-     */
-    messages: any[];
-    /**
-     * Represents each child logger (if any), and the relevant bindings.
-     *
-     * @description 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.
-     */
-    bindings: Bindings[];
-    /**
-     * 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.
-     */
-    level: {
-      label: string;
-      value: number;
-    };
-  } //// Top level variable (const) exports
-  /**
-   * Provides functions for serializing objects common to many projects.
-   */
-  export const stdSerializers: typeof index_d_exports;
-  /**
-   * Holds the current log format version (as output in the v property of each log record).
-   */
-  export const levels: LevelMapping;
-  export 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 stringifySafeSym: unique symbol;
-    readonly stringifiersSym: unique symbol;
-    readonly endSym: unique symbol;
-    readonly formatOptsSym: unique symbol;
-    readonly messageKeySym: unique symbol;
-    readonly errorKeySym: 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;
-  };
-  /**
-   * Exposes the Pino package version. Also available on the logger instance.
-   */
-  export const version: string;
-  /**
-   * 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`.
-   */
-  export const stdTimeFunctions: {
-    /**
-     * The default time function for Pino. Returns a string like `,"time":1493426328206`.
-     */
-    epochTime: TimeFn;
-    /*
-        * Returns the seconds since Unix epoch
-        */
-    unixTime: TimeFn;
-    /**
-     * Returns an empty string. This function is used when the `timestamp` option is set to `false`.
-     */
-    nullTime: TimeFn;
-    /*
-        * Returns ISO 8601-formatted time in UTC
-        */
-    isoTime: TimeFn;
-  }; //// Exported functions
-  /**
-   * Create a Pino Destination instance: a stream-like object with significantly more throughput (over 30%) than a standard Node.js stream.
-   * @param [dest]: The `destination` parameter, can be a file descriptor, a file path, or an object with `dest` property pointing to a fd or path.
-   *                An ordinary Node.js `stream` file descriptor 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
-   */
-  export function destination(dest?: number | object | string | DestinationStream | NodeJS.WritableStream | SonicBoomOpts): SonicBoom;
-  export function transport<TransportOptions = Record<string, any>>(options: TransportSingleOptions<TransportOptions> | TransportMultiOptions<TransportOptions> | TransportPipelineOptions<TransportOptions>): ThreadStream;
-  export function multistream<TLevel = Level>(streamsArray: (DestinationStream | StreamEntry<TLevel>)[] | DestinationStream | StreamEntry<TLevel>, opts?: MultiStreamOptions): MultiStreamRes<TLevel>;
-} //// Callable default export
-/**
- * @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.
- */
-declare 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.
- */
-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
-declare const symbols: typeof pino.symbols;
-// Types
-type Bindings = pino.Bindings;
-type Level = pino.Level;
-type LevelOrString = pino.LevelOrString;
-type LevelWithSilent = pino.LevelWithSilent;
-type LevelWithSilentOrString = pino.LevelWithSilentOrString;
-type Logger<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = pino.Logger<CustomLevels, UseOnlyCustomLevels>;
-type SerializerFn = pino.SerializerFn;
-type WriteFn = pino.WriteFn;
-// Interfaces
-interface BaseLogger extends pino.BaseLogger {}
-interface ChildLoggerOptions<CustomLevels extends string = never> extends pino.ChildLoggerOptions<CustomLevels> {}
-interface DestinationStream extends pino.DestinationStream {}
-interface LevelMapping extends pino.LevelMapping {}
-interface LogEvent extends pino.LogEvent {}
-interface LogFn extends pino.LogFn {}
-interface LoggerOptions<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> extends pino.LoggerOptions<CustomLevels, UseOnlyCustomLevels> {}
-interface MultiStreamOptions extends pino.MultiStreamOptions {}
-interface MultiStreamRes<TLevel = Level> extends pino.MultiStreamRes<TLevel> {}
-interface StreamEntry<TLevel = Level> extends pino.StreamEntry<TLevel> {}
-interface TransportBaseOptions extends pino.TransportBaseOptions {}
-interface TransportMultiOptions extends pino.TransportMultiOptions {}
-interface TransportPipelineOptions extends pino.TransportPipelineOptions {}
-interface TransportSingleOptions extends pino.TransportSingleOptions {}
-interface TransportTargetOptions extends pino.TransportTargetOptions {}
-//#endregion
-export { Logger };
-//# sourceMappingURL=pino.d.ts.map