likec4 1.56.0 → 1.58.0

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

@@ -1,1023 +0,0 @@
-import { i as __name } from "../../rolldown-runtime.mjs";
-
-//#region ../../node_modules/.pnpm/@logtape+logtape@2.0.5/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@2.0.5/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@2.0.5/node_modules/@logtape/logtape/dist/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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.trace(
-   *   'A trace message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  trace(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.debug(
-   *   'A debug message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  debug(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.info(
-   *   'An info message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  info(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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.
-   *
-   * This overload is a shorthand for logging an {@link Error} instance as a
-   * structured property.
-   *
-   * ```typescript
-   * logger.warn(new Error("Oops"));
-   * ```
-   *
-   * Note that this uses `{error.message}` as the default message template.
-   * If you want to include the stack trace in text output, include `{error}`
-   * in the message template instead.
-   *
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  warn(error: Error): void;
-  /**
-   * Log a warning message with an {@link Error}.
-   *
-   * ```typescript
-   * logger.warn("Failed to do something", new Error("Oops"));
-   * ```
-   *
-   * @param message The message.
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  warn(message: string, error: Error): 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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.warn(
-   *   'A warning message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  warn(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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.
-   *
-   * This overload is a shorthand for logging an {@link Error} instance as a
-   * structured property.
-   *
-   * ```typescript
-   * logger.warning(new Error("Oops"));
-   * ```
-   *
-   * Note that this uses `{error.message}` as the default message template.
-   * If you want to include the stack trace in text output, include `{error}`
-   * in the message template instead.
-   *
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  warning(error: Error): void;
-  /**
-   * Log a warning message with an {@link Error}.
-   *
-   * ```typescript
-   * logger.warning("Failed to do something", new Error("Oops"));
-   * ```
-   *
-   * @param message The message.
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  warning(message: string, error: Error): 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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.warning(
-   *   'A warning message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  warning(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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.
-   *
-   * This overload is a shorthand for logging an {@link Error} instance as a
-   * structured property.
-   *
-   * ```typescript
-   * logger.error(new Error("Oops"));
-   * ```
-   *
-   * Note that this uses `{error.message}` as the default message template.
-   * If you want to include the stack trace in text output, include `{error}`
-   * in the message template instead.
-   *
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  error(error: Error): void;
-  /**
-   * Log an error message with an {@link Error}.
-   *
-   * ```typescript
-   * logger.error("Failed to do something", new Error("Oops"));
-   * ```
-   *
-   * @param message The message.
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  error(message: string, error: Error): 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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.error(
-   *   'An error message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  error(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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.
-   *
-   * This overload is a shorthand for logging an {@link Error} instance as a
-   * structured property.
-   *
-   * ```typescript
-   * logger.fatal(new Error("Oops"));
-   * ```
-   *
-   * Note that this uses `{error.message}` as the default message template.
-   * If you want to include the stack trace in text output, include `{error}`
-   * in the message template instead.
-   *
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  fatal(error: Error): void;
-  /**
-   * Log a fatal error message with an {@link Error}.
-   *
-   * ```typescript
-   * logger.fatal("Failed to do something", new Error("Oops"));
-   * ```
-   *
-   * @param message The message.
-   * @param error The error to log.
-   * @since 2.0.0
-   */
-  fatal(message: string, error: Error): 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 message with properties computed asynchronously.
-   *
-   * Use this when the properties require async operations to compute:
-   *
-   * ```typescript
-   * await logger.fatal(
-   *   'A fatal error message with {value}.',
-   *   async () => ({ value: await fetchValue() })
-   * );
-   * ```
-   *
-   * @param message The message template.  Placeholders to be replaced with
-   *                `values` are indicated by keys in curly braces (e.g.,
-   *                `{value}`).
-   * @param properties An async callback that returns the properties.
-   * @returns A promise that resolves when the log is written.
-   * @since 2.0.0
-   */
-  fatal(message: string, properties: () => Promise<Record<string, unknown>>): Promise<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;
-  /**
-   * Check if a message of the given severity level would be processed by
-   * this logger.
-   *
-   * This is useful for conditionally executing expensive computations
-   * before logging, particularly for async operations where lazy
-   * evaluation callbacks cannot be used:
-   *
-   * ```typescript
-   * if (logger.isEnabledFor("debug")) {
-   *   const result = await expensiveAsync();
-   *   logger.debug("Result: {result}", { result });
-   * }
-   * ```
-   *
-   * @param level The log level to check.
-   * @returns `true` if a message of the given level would be logged,
-   *          `false` otherwise.
-   * @since 2.0.0
-   */
-  isEnabledFor(level: LogLevel): boolean;
-}
-/**
- * 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 { Logger as t };