import { CHANNEL_DEFAULTS, ChannelId, Independence } from 'open-verification';
import { PredicateKind } from '../verdict/consequence.js';
/**
 * The sources of truth a verdict can be built from.
 *
 * An implementation declares which of these it can observe. A claim reads one or more of them. Put
 * those two facts together and you can tell, at the moment a connection opens, whether a claim is
 * answerable at all -- rather than finding out after the action has been spent and the moment has
 * passed.
 *
 * That ordering is the whole point. Reticle has a history of discovering a missing observation at
 * assert time and reporting a result that looked like evidence: the assertion could not be answered
 * because nothing was watching, and "nothing was watching" and "it did not happen" produced the same
 * empty answer. Each time, the fix was one more flag on the handshake named for that one case. This
 * is the mechanism those flags were each a hand-made instance of.
 *
 * Names are chosen for what the thing IS, not for what one surface calls it. A browser console, a
 * phone's log stream and a server's stdout are one channel: `log`. A realm that has no console still
 * has somewhere errors go.
 */
export { ChannelId };
/** The channels a claim of this kind needs to look at. */
export declare function channelsRead(kind: PredicateKind): readonly ChannelId[];
/**
 * The independence rule, and where it lives.
 *
 * It is not defined here. It is defined in `open-verification`, the specification this codebase
 * implements, and re-exported here so the rest of the repository can reach it.
 *
 * That direction is the point. A rule this load-bearing, defined in the product and described in
 * the spec, is two definitions of one contract -- and the two would drift the way every such pair
 * drifts, silently and in the product's favour. Defining it in the protocol and importing it here
 * means an implementation cannot quietly hold a more convenient version of the rule than the one
 * it publishes.
 */
export { Independence, CHANNEL_DEFAULTS };
/**
 * May a disagreement between these two channels be reported as a fault?
 *
 * The protocol's rule, reached by channel id rather than by descriptor, because that is the shape
 * every caller here already holds. The judgement itself is not re-implemented -- it is the
 * specification's function, applied to this repository's defaults.
 */
export declare function disagreementCanConvict(a: ChannelId, b: ChannelId): boolean;
/** How independent each channel is, in the shape this repository already reads it in. */
export declare const CHANNEL_INDEPENDENCE: Record<ChannelId, Independence>;