/**
 * The module-private brand key. NEVER exported. Because the symbol is not in
 * scope anywhere outside this file, no external module can write an object
 * literal whose key is `[canonicalBrand]`, so `CanonicalClaim` is opaque at the
 * type level (compile-time leg of defense-in-depth, layer (a)).
 */
declare const canonicalBrand: unique symbol;
/**
 * An opaque, runtime-non-forgeable canonical claim instance — the renderer's
 * REQUIRED input type.
 *
 * The only way to obtain one is the kernel-internal mint (this module's
 * {@link mintCanonicalClaim}, called solely by `runClaimsKernel`); the only way to
 * read the carried fields is {@link unwrapCanonical}, which asserts the value was
 * genuinely minted here. Treat instances as immutable.
 *
 * Carries exactly the renderer-relevant identity of a renderable claim:
 *   - `subject` — the same-subject partition key (P2);
 *   - `type`    — the registry type name (selects the render template);
 *   - `value`   — the domain proposition the renderer fills from. For any claim with
 *                 a render proposition (⟹ a `valueBinding`), the mint NARROWS this to
 *                 the C6-proven slice: only `valueBinding.path` is carried, so the
 *                 value is provably ledger-bound and unbound siblings are STRIPPED
 *                 (F2, RESOLVED — see the mint-site soundness note above). A type
 *                 with no `valueBinding` carries its value unchanged.
 */
export interface CanonicalClaim {
    readonly subject: string;
    readonly type: string;
    readonly value: unknown;
    readonly [canonicalBrand]: true;
}
/**
 * PACKAGE-INTERNAL kernel mint. Deliberately NOT re-exported from the package
 * barrel (`index.ts` / `claims/index.ts` export only the {@link CanonicalClaim}
 * type and {@link unwrapCanonical}) — there is no PUBLIC constructor, per inv.17.
 *
 * The SOLE legitimate caller is `runClaimsKernel`, on a claim that is in the
 * `renderable` set (VALIDATED ∧ P2-consistent). Do not introduce other call
 * sites: minting outside the kernel-validated path would forge canonicity.
 *
 * @internal
 */
export declare function mintCanonicalClaim(subject: string, type: string, value: unknown): CanonicalClaim;
/**
 * Read the carried fields at the renderer boundary, AFTER proving the value was
 * minted by this module. A forged object literal that structurally satisfies
 * `CanonicalClaim` (only constructible via `as`, which the lint layer (c) bans)
 * is rejected here at runtime (defense-in-depth, layer (b)).
 *
 * @throws {Error} if `claim` was not produced by the kernel mint in this module.
 */
export declare function unwrapCanonical(claim: CanonicalClaim): {
    readonly subject: string;
    readonly type: string;
    readonly value: unknown;
};
export {};
//# sourceMappingURL=canonical-claim.d.ts.map