/**
 * @file Private state shared between the `logger/logger` class (which owns the
 *   public `Logger` surface) and `logger/console-init` (which mutates
 *   `Logger.prototype` to mirror `globalConsole`). The `_` prefix keeps this
 *   module out of the generated package.json `exports` map (the `dist/**\/_*`
 *   ignore pattern in `scripts/fix/generate-package-exports.mts` filters it
 *   out), so it is not part of the public surface — it exists only to give the
 *   two leaves above a common owner for the WeakMap-backed lazy-init state. Why
 *   two WeakMaps instead of `#privateField` slots:
 *
 *   - Logger adds dynamic console methods to its prototype at first use (see
 *     `console-init.ts` `ensurePrototypeInitialized`). Those dynamic methods
 *     are constructed via the `{ [key]: function () }` shorthand and CANNOT
 *     access TC39 private fields on `this`.
 *   - WeakMaps work for both the static methods on the `Logger` class body AND
 *     the dynamically-attached prototype methods. WeakMap entries are GC'd
 *     alongside the `Logger` instance.
 *   - `privateConstructorArgs` is deleted after first `Console` build so we don't
 *     pin the original args for the lifetime of the logger.
 */
/**
 * The global `console` reference captured at module load. Pinned to a local so
 * dynamic `console` overrides at runtime can't affect the logger's source
 * console (e.g., test rewiring of `globalThis.console`).
 */
export declare const globalConsole: Console;
/**
 * Property-descriptor template used when registering dynamic console methods on
 * `Logger.prototype`. Writable + configurable so tests can override;
 * non-enumerable so the methods don't leak into `for...in` iteration on a
 * logger instance.
 */
export declare const consolePropAttributes: {
    __proto__: null;
    writable: boolean;
    enumerable: boolean;
    configurable: boolean;
};
/**
 * Cap on the indentation prefix length so a runaway `indent(n)` call with a
 * huge `n` can't allocate a multi-megabyte string.
 */
export declare const maxIndentation = 1000;
/**
 * Pre-bound copies of the console methods that need their original `this` to
 * function (e.g., `console.error.bind(globalConsole)`). Mapping `[name,
 * boundFn]` so `console-init.ts` can apply them onto the per-instance Console
 * without re-binding on every call.
 *
 * Notes from the upstream Node implementation:
 *
 * - `_stderrErrorHandler` / `_stdoutErrorHandler` are `kBindProperties`
 *   properties — they live on the per-instance Console and need their `this`
 *   set to `globalConsole`.
 *   https://github.com/nodejs/node/blob/v24.0.1/lib/internal/console/constructor.js#L230-L265
 * - `group` / `groupCollapsed` / `groupEnd` are explicitly skipped because Node
 *   20 with `--frozen-intrinsics` makes `Symbol(kGroupIndent)` read-only, which
 *   the Logger's own group methods avoid by tracking indentation at the prefix
 *   layer.
 */
export declare const boundConsoleEntries: any[][];
/**
 * WeakMap storing the Console instance for each Logger.
 *
 * Console creation is lazy - deferred until first logging method call. This
 * allows logger to be imported during early Node.js bootstrap before stdout is
 * ready, avoiding ERR_CONSOLE_WRITABLE_STREAM errors.
 */
export declare const privateConsole: WeakMap<WeakKey, any>;
/**
 * WeakMap storing constructor arguments for lazy Console initialization.
 *
 * WeakMap is required instead of a private field (#constructorArgs) because: 1.
 * Private fields can't be accessed from dynamically created functions 2. Logger
 * adds console methods dynamically to its prototype 3. These dynamic methods
 * need constructor args for lazy initialization 4. WeakMap allows both regular
 * methods and dynamic functions to access args.
 *
 * The args are deleted from the WeakMap after Console is created (memory
 * cleanup).
 */
export declare const privateConstructorArgs: WeakMap<WeakKey, any>;
