import { a as Logger, c as LoggerParamsWithLevels, i as LogChunk, n as CreateLogger, o as LoggerLevelsConfig, r as GetLevelNames, s as LoggerParams } from "../utils-CASaFzLf.mjs";
import { AnyRecord } from "@neodx/std";
import { PathLike } from "node:fs";
import { ColorName, Colors } from "@neodx/colors";
import { Writable } from "node:stream";
//#region src/utils/create-auto-logger-factory.d.ts
type AutoLoggerInput<Level extends string> = Level | (Partial<LoggerParams<Level>> & Pick<LoggerParams<Level>, 'level'>) | 'silent' | Logger<Level>;
//#endregion
//#region src/utils/read-arguments.d.ts
type LogArguments = [messageFragments: unknown[], meta: AnyRecord, error?: Error];
//#endregion
//#region src/core/create-logger-factory.d.ts
interface CreateLoggerFactoryParams<Levels extends LoggerLevelsConfig<string>> {
  defaultParams: LoggerParamsWithLevels<Levels>;
  readArguments(args: unknown[]): LogArguments;
  /**
   * Formats a message template with replaces.
   * @default Our lightweight implementation with %s, %d, %i, %f, %j/%o/%O (same output as %j) support
   * @example (template, replaces) => util.format(template, ...replaces) // Node.js util.format
   */
  formatMessage(template: string, replaces: unknown[]): string;
}
declare function createLoggerFactory<LevelsConfig extends LoggerLevelsConfig<string>>({ defaultParams, formatMessage, readArguments }: CreateLoggerFactoryParams<LevelsConfig>): CreateLogger<GetLevelNames<LevelsConfig>>;
//#endregion
//#region src/core/shared.d.ts
type DefaultLoggerLevel = keyof DefaultLoggerLevelsConfig;
type DefaultLoggerLevelsConfig = typeof DEFAULT_LOGGER_LEVELS;
declare const LOGGER_SILENT_LEVEL: "silent";
declare const DEFAULT_LOGGER_LEVELS: {
  error: number;
  warn: number;
  info: number;
  done: number;
  debug: number;
  success: "done";
  verbose: "debug";
  silent: number;
};
declare const DEFAULT_LOGGER_PARAMS: {
  levels: {
    error: number;
    warn: number;
    info: number;
    done: number;
    debug: number;
    success: "done";
    verbose: "debug";
    silent: number;
  };
  level: "done";
  name: string;
  transform: never[];
  target: never[];
  meta: {};
};
//#endregion
//#region src/node/error/print-code-frame.d.ts
interface PrintCodeFrameOptions {
  colors?: Colors;
  source: string;
  indent?: number;
  lineNumber: number;
  columnNumber: number;
  overscan?: number;
}
declare function printCodeFrame({ colors, indent, columnNumber, lineNumber, source, overscan }: PrintCodeFrameOptions): string;
//#endregion
//#region src/node/error/stack-trace.d.ts
interface ParsedStack {
  file: string;
  line: number;
  method: string;
  column: number;
}
//#endregion
//#region src/node/error/print-pretty-error.d.ts
interface PrintPrettyErrorOptions {
  cwd?: string;
  indent?: number;
  colors?: Colors;
  fullStack?: boolean;
  codeFrame?: boolean | 'auto' | GetHighlightStacks;
  stringify?: (value: unknown) => string;
  filterStack?: (stack: ParsedStack) => boolean;
}
type GetHighlightStacks = (stacks: ParsedStack[]) => ParsedStack | ParsedStack[];
declare function printPrettyError(originalError: unknown, options?: PrintPrettyErrorOptions): string;
//#endregion
//#region src/node/serializers.d.ts
type LogSerializers = Record<string, LogSerializer>;
type LogSerializer = (value: any) => any;
//#endregion
//#region src/node/json.d.ts
interface JsonTargetParams {
  target?: Writable | ((...args: unknown[]) => void);
  dateKey?: string;
  errorKey?: string;
  messageKey?: string;
  serializers?: LogSerializers;
  levelValueKey?: string;
}
declare function file(filename: PathLike, options?: Omit<JsonTargetParams, 'target'>): ({ msg, error, meta, level, name, date, __: { levels } }: LogChunk<string>) => void;
declare function json({ target, dateKey, errorKey, messageKey, serializers, levelValueKey }?: JsonTargetParams): ({ msg, error, meta, level, name, date, __: { levels } }: LogChunk<string>) => void;
//#endregion
//#region src/node/pretty.d.ts
interface PrettyTargetParams<Level extends string> {
  /**
   * Default handler for log messages without errors.
   */
  log?(...args: unknown[]): void;
  /**
   * Default handler for log messages with errors (e.g. `logger.error(new Error(), 'message')`).
   */
  logError?(...args: unknown[]): void;
  /**
   * Custom implementation of colors from `@neodx/colors` or other libraries with same contracts.
   * @example `createColors(false, false)` - disable colors completely
   */
  colors?: Colors;
  /**
   * Display milliseconds in log message (e.g. `12:34:56.789`).
   * Works only if `displayTime` is `true`.
   */
  displayMs?: boolean;
  serializers?: LogSerializers;
  /**
   * Display time in a log message
   */
  displayTime?: boolean;
  /**
   * Display log level in log message.
   */
  displayLevel?: boolean;
  prettyErrors?: boolean | Partial<PrintPrettyErrorOptions>;
  levelColors?: Partial<Record<Level, ColorName>> | null;
  levelBadges?: Partial<Record<Level, string>> | null;
}
/**
 * Creates a pretty log handler for development mode in node.
 */
declare function pretty<const Level extends string>({ log, logError, colors, displayMs, serializers, displayTime, displayLevel, prettyErrors, levelColors, levelBadges }?: PrettyTargetParams<Level>): (chunk: LogChunk<Level>) => void;
declare namespace pretty {
  var defaultBadges: Partial<Record<"silent" | "error" | "warn" | "info" | "done" | "debug" | "success" | "verbose", string>>;
  var defaultColors: Partial<Record<"silent" | "error" | "warn" | "info" | "done" | "debug" | "success" | "verbose", "reset" | "bold" | "dim" | "italic" | "overline" | "underline" | "inverse" | "hidden" | "strikethrough" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite">>;
}
//#endregion
//#region src/node/index.d.ts
declare const NODE_LOGGER_SYSTEM_INFO: {
  pid: number;
  hostname: string;
};
declare const createLogger: CreateLogger<"silent" | "error" | "warn" | "info" | "done" | "debug" | "success" | "verbose">;
declare const createAutoLogger: <const Level extends string>(log: AutoLoggerInput<Level>, defaultParams?: Partial<LoggerParams<Level>>) => Logger<Level>;
//#endregion
export { type CreateLoggerFactoryParams, DEFAULT_LOGGER_LEVELS, DEFAULT_LOGGER_PARAMS, type DefaultLoggerLevel, type JsonTargetParams, LOGGER_SILENT_LEVEL, NODE_LOGGER_SYSTEM_INFO, type PrettyTargetParams, type PrintCodeFrameOptions, type PrintPrettyErrorOptions, createAutoLogger, createLogger, createLoggerFactory, file, json, pretty, printCodeFrame, printPrettyError };
//# sourceMappingURL=index.d.mts.map