@likec4/log 1.49.0 → 1.51.0

package/dist/_chunks/libs/@logtape/logtape.d.mts

@@ -0,0 +1,1278 @@
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/context.d.ts
+//#region src/context.d.ts
+/**
+ * A generic interface for a context-local storage.  It resembles
+ * the {@link AsyncLocalStorage} API from Node.js.
+ * @template T The type of the context-local store.
+ * @since 0.7.0
+ */
+interface ContextLocalStorage<T> {
+  /**
+   * Runs a callback with the given store as the context-local store.
+   * @param store The store to use as the context-local store.
+   * @param callback The callback to run.
+   * @returns The return value of the callback.
+   */
+  run<R>(store: T, callback: () => R): R;
+  /**
+   * Returns the current context-local store.
+   * @returns The current context-local store, or `undefined` if there is no
+   *          store.
+   */
+  getStore(): T | undefined;
+}
+/**
+ * Runs a callback with the given implicit context.  Every single log record
+ * in the callback will have the given context.
+ *
+ * If no `contextLocalStorage` is configured, this function does nothing and
+ * just returns the return value of the callback.  It also logs a warning to
+ * the `["logtape", "meta"]` logger in this case.
+ * @param context The context to inject.
+ * @param callback The callback to run.
+ * @returns The return value of the callback.
+ * @since 0.7.0
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/level.d.ts
+//#region src/level.d.ts
+declare const logLevels: readonly ["trace", "debug", "info", "warning", "error", "fatal"];
+/**
+ * The severity level of a {@link LogRecord}.
+ */
+type LogLevel = typeof logLevels[number];
+/**
+ * Lists all available log levels with the order of their severity.
+ * The `"trace"` level goes first, and the `"fatal"` level goes last.
+ * @returns A new copy of the array of log levels.
+ * @since 1.0.0
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/record.d.ts
+//#region src/record.d.ts
+/**
+ * A log record.
+ */
+interface LogRecord {
+  /**
+   * The category of the logger that produced the log record.
+   */
+  readonly category: readonly string[];
+  /**
+   * The log level.
+   */
+  readonly level: LogLevel;
+  /**
+   * The log message.  This is the result of substituting the message template
+   * with the values.  The number of elements in this array is always odd,
+   * with the message template values interleaved between the substitution
+   * values.
+   */
+  readonly message: readonly unknown[];
+  /**
+   * The raw log message.  This is the original message template without any
+   * further processing.  It can be either:
+   *
+   * - A string without any substitutions if the log record was created with
+   *   a method call syntax, e.g., "Hello, {name}!" for
+   *   `logger.info("Hello, {name}!", { name })`.
+   * - A template string array if the log record was created with a tagged
+   *   template literal syntax, e.g., `["Hello, ", "!"]` for
+   *   ``logger.info`Hello, ${name}!```.
+   *
+   * @since 0.6.0
+   */
+  readonly rawMessage: string | TemplateStringsArray;
+  /**
+   * The timestamp of the log record in milliseconds since the Unix epoch.
+   */
+  readonly timestamp: number;
+  /**
+   * The extra properties of the log record.
+   */
+  readonly properties: Record<string, unknown>;
+} //# sourceMappingURL=record.d.ts.map
+//#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/filter.d.ts
+//#region src/filter.d.ts
+/**
+ * A filter is a function that accepts a log record and returns `true` if the
+ * record should be passed to the sink.
+ *
+ * @param record The log record to filter.
+ * @returns `true` if the record should be passed to the sink.
+ */
+type Filter = (record: LogRecord) => boolean;
+/**
+ * A filter-like value is either a {@link Filter} or a {@link LogLevel}.
+ * `null` is also allowed to represent a filter that rejects all records.
+ */
+type FilterLike = Filter | LogLevel | null;
+/**
+ * Converts a {@link FilterLike} value to an actual {@link Filter}.
+ *
+ * @param filter The filter-like value to convert.
+ * @returns The actual filter.
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/formatter.d.ts
+//#region src/formatter.d.ts
+/**
+ * A text formatter is a function that accepts a log record and returns
+ * a string.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record.
+ */
+type TextFormatter = (record: LogRecord) => string;
+/**
+ * The formatted values for a log record.
+ * @since 0.6.0
+ */
+interface FormattedValues {
+  /**
+   * The formatted timestamp.
+   */
+  timestamp: string | null;
+  /**
+   * The formatted log level.
+   */
+  level: string;
+  /**
+   * The formatted category.
+   */
+  category: string;
+  /**
+   * The formatted message.
+   */
+  message: string;
+  /**
+   * The unformatted log record.
+   */
+  record: LogRecord;
+}
+/**
+ * The various options for the built-in text formatters.
+ * @since 0.6.0
+ */
+interface TextFormatterOptions {
+  /**
+   * The timestamp format.  This can be one of the following:
+   *
+   * - `"date-time-timezone"`: The date and time with the full timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00:00"`).
+   * - `"date-time-tz"`: The date and time with the short timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00"`).
+   * - `"date-time"`: The date and time without the timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000"`).
+   * - `"time-timezone"`: The time with the full timezone offset but without
+   *   the date (e.g., `"22:13:20.000 +00:00"`).
+   * - `"time-tz"`: The time with the short timezone offset but without the date
+   *   (e.g., `"22:13:20.000 +00"`).
+   * - `"time"`: The time without the date or timezone offset
+   *   (e.g., `"22:13:20.000"`).
+   * - `"date"`: The date without the time or timezone offset
+   *   (e.g., `"2023-11-14"`).
+   * - `"rfc3339"`: The date and time in RFC 3339 format
+   *   (e.g., `"2023-11-14T22:13:20.000Z"`).
+   * - `"none"` or `"disabled"`: No display
+   *
+   * Alternatively, this can be a function that accepts a timestamp and returns
+   * a string.
+   *
+   * The default is `"date-time-timezone"`.
+   */
+  timestamp?: "date-time-timezone" | "date-time-tz" | "date-time" | "time-timezone" | "time-tz" | "time" | "date" | "rfc3339" | "none" | "disabled" | ((ts: number) => string | null);
+  /**
+   * The log level format.  This can be one of the following:
+   *
+   * - `"ABBR"`: The log level abbreviation in uppercase (e.g., `"INF"`).
+   * - `"FULL"`: The full log level name in uppercase (e.g., `"INFO"`).
+   * - `"L"`: The first letter of the log level in uppercase (e.g., `"I"`).
+   * - `"abbr"`: The log level abbreviation in lowercase (e.g., `"inf"`).
+   * - `"full"`: The full log level name in lowercase (e.g., `"info"`).
+   * - `"l"`: The first letter of the log level in lowercase (e.g., `"i"`).
+   *
+   * Alternatively, this can be a function that accepts a log level and returns
+   * a string.
+   *
+   * The default is `"ABBR"`.
+   */
+  level?: "ABBR" | "FULL" | "L" | "abbr" | "full" | "l" | ((level: LogLevel) => string);
+  /**
+   * The separator between category names.  For example, if the separator is
+   * `"·"`, the category `["a", "b", "c"]` will be formatted as `"a·b·c"`.
+   * The default separator is `"·"`.
+   *
+   * If this is a function, it will be called with the category array and
+   * should return a string, which will be used for rendering the category.
+   */
+  category?: string | ((category: readonly string[]) => string);
+  /**
+   * The format of the embedded values.
+   *
+   * A function that renders a value to a string.  This function is used to
+   * render the values in the log record.  The default is a cross-runtime
+   * `inspect()` function that uses [`util.inspect()`] in Node.js/Bun,
+   * [`Deno.inspect()`] in Deno, or falls back to {@link JSON.stringify} in
+   * browsers.
+   *
+   * The second parameter provides access to the default cross-runtime
+   * `inspect()` function, allowing you to fall back to the default behavior
+   * for certain values while customizing others.  You can ignore this
+   * parameter if you don't need the fallback functionality.
+   *
+   * [`util.inspect()`]: https://nodejs.org/api/util.html#utilinspectobject-options
+   * [`Deno.inspect()`]: https://docs.deno.com/api/deno/~/Deno.inspect
+   * @param value The value to render.
+   * @param inspect The default cross-runtime inspect function that can be used
+   *                as a fallback.  Accepts an optional `options` parameter
+   *                with a `colors` boolean field.
+   * @returns The string representation of the value.
+   * @example
+   * ```typescript
+   * getTextFormatter({
+   *   value(value, inspect) {
+   *     // Custom formatting for numbers
+   *     if (typeof value === 'number') {
+   *       return value.toFixed(2);
+   *     }
+   *     // Fall back to default for everything else
+   *     return inspect(value);
+   *   }
+   * })
+   * ```
+   */
+  value?: (value: unknown, inspect: (value: unknown, options?: {
+    colors?: boolean;
+  }) => string) => string;
+  /**
+   * How those formatted parts are concatenated.
+   *
+   * A function that formats the log record.  This function is called with the
+   * formatted values and should return a string.  Note that the formatted
+   * *should not* include a newline character at the end.
+   *
+   * By default, this is a function that formats the log record as follows:
+   *
+   * ```
+   * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+   * ```
+   * @param values The formatted values.
+   * @returns The formatted log record.
+   */
+  format?: (values: FormattedValues) => string;
+}
+/**
+ * Get a text formatter with the specified options.  Although it's flexible
+ * enough to create a custom formatter, if you want more control, you can
+ * create a custom formatter that satisfies the {@link TextFormatter} type
+ * instead.
+ *
+ * For more information on the options, see {@link TextFormatterOptions}.
+ *
+ * By default, the formatter formats log records as follows:
+ *
+ * ```
+ * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
+ * ```
+ * @param options The options for the text formatter.
+ * @returns The text formatter.
+ * @since 0.6.0
+ */
+/**
+ * The ANSI colors.  These can be used to colorize text in the console.
+ * @since 0.6.0
+ */
+type AnsiColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+/**
+ * The ANSI text styles.
+ * @since 0.6.0
+ */
+type AnsiStyle = "bold" | "dim" | "italic" | "underline" | "strikethrough";
+/**
+ * The various options for the ANSI color formatter.
+ * @since 0.6.0
+ */
+interface AnsiColorFormatterOptions extends TextFormatterOptions {
+  /**
+   * The timestamp format.  This can be one of the following:
+   *
+   * - `"date-time-timezone"`: The date and time with the full timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00:00"`).
+   * - `"date-time-tz"`: The date and time with the short timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000 +00"`).
+   * - `"date-time"`: The date and time without the timezone offset
+   *   (e.g., `"2023-11-14 22:13:20.000"`).
+   * - `"time-timezone"`: The time with the full timezone offset but without
+   *   the date (e.g., `"22:13:20.000 +00:00"`).
+   * - `"time-tz"`: The time with the short timezone offset but without the date
+   *   (e.g., `"22:13:20.000 +00"`).
+   * - `"time"`: The time without the date or timezone offset
+   *   (e.g., `"22:13:20.000"`).
+   * - `"date"`: The date without the time or timezone offset
+   *   (e.g., `"2023-11-14"`).
+   * - `"rfc3339"`: The date and time in RFC 3339 format
+   *   (e.g., `"2023-11-14T22:13:20.000Z"`).
+   *
+   * Alternatively, this can be a function that accepts a timestamp and returns
+   * a string.
+   *
+   * The default is `"date-time-tz"`.
+   */
+  timestamp?: "date-time-timezone" | "date-time-tz" | "date-time" | "time-timezone" | "time-tz" | "time" | "date" | "rfc3339" | ((ts: number) => string);
+  /**
+   * The ANSI style for the timestamp.  `"dim"` is used by default.
+   */
+  timestampStyle?: AnsiStyle | null;
+  /**
+   * The ANSI color for the timestamp.  No color is used by default.
+   */
+  timestampColor?: AnsiColor | null;
+  /**
+   * The ANSI style for the log level.  `"bold"` is used by default.
+   */
+  levelStyle?: AnsiStyle | null;
+  /**
+   * The ANSI colors for the log levels.  The default colors are as follows:
+   *
+   * - `"trace"`: `null` (no color)
+   * - `"debug"`: `"blue"`
+   * - `"info"`: `"green"`
+   * - `"warning"`: `"yellow"`
+   * - `"error"`: `"red"`
+   * - `"fatal"`: `"magenta"`
+   */
+  levelColors?: Record<LogLevel, AnsiColor | null>;
+  /**
+   * The ANSI style for the category.  `"dim"` is used by default.
+   */
+  categoryStyle?: AnsiStyle | null;
+  /**
+   * The ANSI color for the category.  No color is used by default.
+   */
+  categoryColor?: AnsiColor | null;
+}
+/**
+ * Get an ANSI color formatter with the specified options.
+ *
+ * ![A preview of an ANSI color formatter.](https://i.imgur.com/I8LlBUf.png)
+ * @param option The options for the ANSI color formatter.
+ * @returns The ANSI color formatter.
+ * @since 0.6.0
+ */
+/**
+ * A console formatter is a function that accepts a log record and returns
+ * an array of arguments to pass to {@link console.log}.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record, as an array of arguments for
+ *          {@link console.log}.
+ */
+type ConsoleFormatter = (record: LogRecord) => readonly unknown[];
+/**
+ * The default console formatter.
+ *
+ * @param record The log record to format.
+ * @returns The formatted log record, as an array of arguments for
+ *          {@link console.log}.
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/sink.d.ts
+//#region src/sink.d.ts
+/**
+ * A sink is a function that accepts a log record and prints it somewhere.
+ * Thrown exceptions will be suppressed and then logged to the meta logger,
+ * a {@link Logger} with the category `["logtape", "meta"]`.  (In that case,
+ * the meta log record will not be passed to the sink to avoid infinite
+ * recursion.)
+ *
+ * @param record The log record to sink.
+ */
+type Sink = (record: LogRecord) => void;
+/**
+ * An async sink is a function that accepts a log record and asynchronously
+ * processes it. This type is used with {@link fromAsyncSink} to create
+ * a regular sink that properly handles asynchronous operations.
+ *
+ * @param record The log record to process asynchronously.
+ * @returns A promise that resolves when the record has been processed.
+ * @since 1.0.0
+ */
+/**
+ * Turns a sink into a filtered sink.  The returned sink only logs records that
+ * pass the filter.
+ *
+ * @example Filter a console sink to only log records with the info level
+ * ```typescript
+ * const sink = withFilter(getConsoleSink(), "info");
+ * ```
+ *
+ * @param sink A sink to be filtered.
+ * @param filter A filter to apply to the sink.  It can be either a filter
+ *               function or a {@link LogLevel} string.
+ * @returns A sink that only logs records that pass the filter.
+ */
+declare function withFilter(sink: Sink, filter: FilterLike): Sink;
+/**
+ * Options for the {@link getStreamSink} function.
+ */
+type ConsoleMethod = "debug" | "info" | "log" | "warn" | "error";
+/**
+ * Options for the {@link getConsoleSink} function.
+ */
+interface ConsoleSinkOptions {
+  /**
+   * The console formatter or text formatter to use.
+   * Defaults to {@link defaultConsoleFormatter}.
+   */
+  formatter?: ConsoleFormatter | TextFormatter;
+  /**
+   * The mapping from log levels to console methods.  Defaults to:
+   *
+   * ```typescript
+   * {
+   *   trace: "trace",
+   *   debug: "debug",
+   *   info: "info",
+   *   warning: "warn",
+   *   error: "error",
+   *   fatal: "error",
+   * }
+   * ```
+   * @since 0.9.0
+   */
+  levelMap?: Record<LogLevel, ConsoleMethod>;
+  /**
+   * The console to log to.  Defaults to {@link console}.
+   */
+  console?: Console;
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getConsoleSink({ nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getConsoleSink({
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
+}
+/**
+ * A console sink factory that returns a sink that logs to the console.
+ *
+ * @param options The options for the sink.
+ * @returns A sink that logs to the console. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link Disposable}.
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/config.d.ts
+//#region src/config.d.ts
+/**
+ * A configuration for the loggers.
+ */
+interface Config<TSinkId extends string, TFilterId extends string> {
+  /**
+   * The sinks to use.  The keys are the sink identifiers, and the values are
+   * {@link Sink}s.
+   */
+  sinks: Record<TSinkId, Sink>;
+  /**
+   * The filters to use.  The keys are the filter identifiers, and the values
+   * are either {@link Filter}s or {@link LogLevel}s.
+   */
+  filters?: Record<TFilterId, FilterLike>;
+  /**
+   * The loggers to configure.
+   */
+  loggers: LoggerConfig<TSinkId, TFilterId>[];
+  /**
+   * The context-local storage to use for implicit contexts.
+   * @since 0.7.0
+   */
+  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;
+  /**
+   * Whether to reset the configuration before applying this one.
+   */
+  reset?: boolean;
+}
+/**
+ * A logger configuration.
+ */
+interface LoggerConfig<TSinkId extends string, TFilterId extends string> {
+  /**
+   * The category of the logger.  If a string, it is equivalent to an array
+   * with one element.
+   */
+  category: string | string[];
+  /**
+   * The sink identifiers to use.
+   */
+  sinks?: TSinkId[];
+  /**
+   * Whether to inherit the parent's sinks.  If `inherit`, the parent's sinks
+   * are used along with the specified sinks.  If `override`, the parent's
+   * sinks are not used, and only the specified sinks are used.
+   *
+   * The default is `inherit`.
+   * @default `"inherit"
+   * @since 0.6.0
+   */
+  parentSinks?: "inherit" | "override";
+  /**
+   * The filter identifiers to use.
+   */
+  filters?: TFilterId[];
+  /**
+   * The lowest log level to accept.  If `null`, the logger will reject all
+   * records.
+   * @since 0.8.0
+   */
+  lowestLevel?: LogLevel | null;
+}
+/**
+ * Configure the loggers with the specified configuration.
+ *
+ * Note that if the given sinks or filters are disposable, they will be
+ * disposed when the configuration is reset, or when the process exits.
+ *
+ * @example
+ * ```typescript
+ * await configure({
+ *   sinks: {
+ *     console: getConsoleSink(),
+ *   },
+ *   filters: {
+ *     slow: (log) =>
+ *       "duration" in log.properties &&
+ *       log.properties.duration as number > 1000,
+ *   },
+ *   loggers: [
+ *     {
+ *       category: "my-app",
+ *       sinks: ["console"],
+ *       lowestLevel: "info",
+ *     },
+ *     {
+ *       category: ["my-app", "sql"],
+ *       filters: ["slow"],
+ *       lowestLevel: "debug",
+ *     },
+ *     {
+ *       category: "logtape",
+ *       sinks: ["console"],
+ *       lowestLevel: "error",
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @param config The configuration.
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@logtape+logtape@1.3.7/node_modules/@logtape/logtape/dist/logger.d.ts
+//#region src/logger.d.ts
+/**
+ * A logger interface.  It provides methods to log messages at different
+ * severity levels.
+ *
+ * ```typescript
+ * const logger = getLogger("category");
+ * logger.trace `A trace message with ${value}`
+ * logger.debug `A debug message with ${value}.`;
+ * logger.info `An info message with ${value}.`;
+ * logger.warn `A warning message with ${value}.`;
+ * logger.error `An error message with ${value}.`;
+ * logger.fatal `A fatal error message with ${value}.`;
+ * ```
+ */
+interface Logger {
+  /**
+   * The category of the logger.  It is an array of strings.
+   */
+  readonly category: readonly string[];
+  /**
+   * The logger with the supercategory of the current logger.  If the current
+   * logger is the root logger, this is `null`.
+   */
+  readonly parent: Logger | null;
+  /**
+   * Get a child logger with the given subcategory.
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * const subLogger = logger.getChild("sub-category");
+   * ```
+   *
+   * The above code is equivalent to:
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * const subLogger = getLogger(["category", "sub-category"]);
+   * ```
+   *
+   * @param subcategory The subcategory.
+   * @returns The child logger.
+   */
+  getChild(subcategory: string | readonly [string] | readonly [string, ...string[]]): Logger;
+  /**
+   * Get a logger with contextual properties.  This is useful for
+   * log multiple messages with the shared set of properties.
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * const ctx = logger.with({ foo: 123, bar: "abc" });
+   * ctx.info("A message with {foo} and {bar}.");
+   * ctx.warn("Another message with {foo}, {bar}, and {baz}.", { baz: true });
+   * ```
+   *
+   * The above code is equivalent to:
+   *
+   * ```typescript
+   * const logger = getLogger("category");
+   * logger.info("A message with {foo} and {bar}.", { foo: 123, bar: "abc" });
+   * logger.warn(
+   *   "Another message with {foo}, {bar}, and {baz}.",
+   *   { foo: 123, bar: "abc", baz: true },
+   * );
+   * ```
+   *
+   * @param properties
+   * @returns
+   * @since 0.5.0
+   */
+  with(properties: Record<string, unknown>): Logger;
+  /**
+   * Log a trace message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.trace `A trace message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a trace message with properties.
+   *
+   * ```typescript
+   * logger.trace('A trace message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.trace(
+   *   'A trace message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  trace(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a trace values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.trace({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.trace('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.trace('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  trace(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a trace message.  Use this when the message values are expensive
+   * to compute and should only be computed if the message is actually logged.
+   *
+   * ```typescript
+   * logger.trace(l => l`A trace message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  trace(callback: LogCallback): void;
+  /**
+   * Log a debug message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.debug `A debug message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a debug message with properties.
+   *
+   * ```typescript
+   * logger.debug('A debug message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.debug(
+   *   'A debug message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  debug(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a debug values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.debug({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.debug('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.debug('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  debug(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a debug message.  Use this when the message values are expensive
+   * to compute and should only be computed if the message is actually logged.
+   *
+   * ```typescript
+   * logger.debug(l => l`A debug message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  debug(callback: LogCallback): void;
+  /**
+   * Log an informational message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.info `An info message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log an informational message with properties.
+   *
+   * ```typescript
+   * logger.info('An info message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.info(
+   *   'An info message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  info(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an informational values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.info({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.info('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.info('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  info(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log an informational message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.info(l => l`An info message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  info(callback: LogCallback): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warn `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warn('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warn(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  warn(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warn({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warn('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warn('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  warn(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warn(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  warn(callback: LogCallback): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  warning(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  warning(callback: LogCallback): void;
+  /**
+   * Log an error message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.error `An error message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log an error message with properties.
+   *
+   * ```typescript
+   * logger.warn('An error message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.error(
+   *   'An error message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  error(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an error values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.error({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.error('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.error('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  error(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log an error message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.error(l => l`An error message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  error(callback: LogCallback): void;
+  /**
+   * Log a fatal error message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.fatal `A fatal error message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   */
+  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a fatal error message with properties.
+   *
+   * ```typescript
+   * logger.warn('A fatal error message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.fatal(
+   *   'A fatal error message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   */
+  fatal(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a fatal error values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.fatal({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.fatal('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.fatal('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.11.0
+   */
+  fatal(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a fatal error message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   */
+  fatal(callback: LogCallback): void;
+  /**
+   * Emits a log record with custom fields while using this logger's
+   * category.
+   *
+   * This is a low-level API for integration scenarios where you need full
+   * control over the log record, particularly for preserving timestamps
+   * from external systems.
+   *
+   * ```typescript
+   * const logger = getLogger(["my-app", "integration"]);
+   *
+   * // Emit a log with a custom timestamp
+   * logger.emit({
+   *   timestamp: kafkaLog.originalTimestamp,
+   *   level: "info",
+   *   message: [kafkaLog.message],
+   *   rawMessage: kafkaLog.message,
+   *   properties: {
+   *     source: "kafka",
+   *     partition: kafkaLog.partition,
+   *     offset: kafkaLog.offset,
+   *   },
+   * });
+   * ```
+   *
+   * @param record Log record without category field (category comes from
+   *               the logger instance)
+   * @since 1.1.0
+   */
+  emit(record: Omit<LogRecord, "category">): void;
+}
+/**
+ * A logging callback function.  It is used to defer the computation of a
+ * message template until it is actually logged.
+ * @param prefix The message template prefix.
+ * @returns The rendered message array.
+ */
+type LogCallback = (prefix: LogTemplatePrefix) => unknown[];
+/**
+ * A logging template prefix function.  It is used to log a message in
+ * a {@link LogCallback} function.
+ * @param message The message template strings array.
+ * @param values The message template values.
+ * @returns The rendered message array.
+ */
+type LogTemplatePrefix = (message: TemplateStringsArray, ...values: unknown[]) => unknown[];
+/**
+ * A function type for logging methods in the {@link Logger} interface.
+ * @since 1.0.0
+ */
+//#endregion
+export { withFilter as a, TextFormatter as c, LogRecord as d, LogLevel as f, Sink as i, TextFormatterOptions as l, Config as n, AnsiColorFormatterOptions as o, ConsoleSinkOptions as r, ConsoleFormatter as s, Logger as t, Filter as u };