import type { Logger } from "@rotorsoft/act/types";
/**
 * One {@link Logger} implementation to feed into
 * {@link runLoggerDifferentialTck}. The harness drives the identical call
 * sequence against all of them and compares the **portable** observable
 * contract — robustness (does a call throw?) and structural conformance
 * (is `level` a non-empty string, does `child()` satisfy the contract).
 */
export type DifferentialLogger = {
    /** Display name used in assertion messages and the describe block. */
    readonly name: string;
    /**
     * Produces the logger under test. Called before each test; the harness
     * owns its lifecycle (`dispose`).
     */
    readonly factory: () => Logger;
};
/**
 * Options for {@link runLoggerDifferentialTck}.
 */
export type LoggerDifferentialTckOptions = {
    /** Display name for the differential suite. */
    readonly name: string;
    /**
     * Two or more loggers to drive in lockstep and compare. The first entry
     * is the reference; every other logger must uphold the same portable
     * observable contract under the identical call sequence.
     */
    readonly loggers: ReadonlyArray<DifferentialLogger>;
};
/**
 * Cross-implementation differential contract for the {@link Logger} port
 * (#1057).
 *
 * A logger has no portable return value to byte-compare — its output
 * format is adapter-specific by design, which is exactly why
 * {@link runLoggerTck} checks shape rather than bytes. The meaningful
 * differential is therefore **robustness and structural parity**: driven
 * through the identical call sequence (every level, both overloads, null
 * and cyclic payloads, child spawning), do two implementations agree on
 * what throws and what conforms? They must. A logger that throws on a
 * cyclic payload the reference tolerates, or returns a non-conforming
 * child, diverges from the reference vector.
 *
 * @example
 * ```ts
 * import { runLoggerDifferentialTck } from "@rotorsoft/act-tck";
 * import { ConsoleLogger } from "@rotorsoft/act";
 * import { PinoLogger } from "../src/index.js";
 *
 * runLoggerDifferentialTck({
 *   name: "Console vs Pino",
 *   loggers: [
 *     { name: "ConsoleLogger", factory: () => new ConsoleLogger({ level: "trace" }) },
 *     { name: "PinoLogger", factory: () => new PinoLogger({ level: "trace" }) },
 *   ],
 * });
 * ```
 */
export declare const runLoggerDifferentialTck: (options: LoggerDifferentialTckOptions) => void;
//# sourceMappingURL=logger-differential-tck.d.ts.map