/**
 * Trace admission control: the {@link SampleGate}.
 *
 * A {@link Recorder} consults a gate once per `open` to decide whether a new
 * trace is recorded at all. Three strategies cover the useful spectrum:
 *
 * - `"always"` — admit everything (the default; good for dev/diagnostics).
 * - `"never"`  — admit nothing (a kill-switch that keeps call sites intact).
 * - `{ ratio }` — admit a deterministic fraction in `[0, 1]`, keyed by the
 *   trace id, so the *same* trace id always yields the *same* verdict. This is
 *   ratio sampling without a random draw: the decision is reproducible across
 *   processes and replays, and a child opened on an admitted trace id is itself
 *   admitted (the whole trace is consistently in or out).
 *
 * The ratio hash is a small, dependency-free FNV-1a over the trace id's bytes,
 * folded to a unit fraction. It is *not* cryptographic — it only needs to spread
 * hex trace ids roughly uniformly across `[0, 1)`, which FNV-1a does well enough
 * for sampling. (Trace ids are themselves minted from `node:crypto`, so the
 * input is already high-entropy.)
 */
/** A deterministic ratio strategy: admit a fraction `ratio ∈ [0, 1]` of traces. */
export interface RatioStrategy {
    readonly ratio: number;
}
/**
 * How a {@link SampleGate} decides admission.
 *
 * `"always"`/`"never"` are constant verdicts; `{ ratio }` is a per-trace-id
 * deterministic fraction.
 */
export type SampleStrategy = "always" | "never" | RatioStrategy;
/**
 * Admission control for traces.
 *
 * Construct with a {@link SampleStrategy} and call {@link decide} with a trace
 * id; the verdict is constant for `"always"`/`"never"` and deterministic per id
 * for a ratio. A gate holds no mutable state, so a single instance is safely
 * shared across recorders and threads of execution.
 */
export declare class SampleGate {
    private readonly strategy;
    /** Pre-clamped admission threshold for the ratio strategy; unused otherwise. */
    private readonly threshold;
    constructor(strategy?: SampleStrategy);
    /**
     * Decide whether the trace identified by `traceId` is admitted.
     *
     * - `"always"` → always `true`.
     * - `"never"`  → always `false`.
     * - `{ ratio }` → `unitHash(traceId) < ratio` (clamped): deterministic, so the
     *   same id always yields the same answer. Ratio `0` admits nothing and ratio
     *   `1` admits everything regardless of the hash.
     */
    decide(traceId: string): boolean;
}
