/**
 * PrivacyPort — V0 noop stub for Vauban Privacy Protocol (VPP) integration.
 *
 * Implements S0 port #10 (PrivacyPort): placeholder interface for privacy-preserving
 * operations. Phase 2+ will implement full Stwo+ML-KEM+viewing-key+SMT+cross-domain
 * functionality per draft-vauban-privacy-protocol-00 (target IETF submission 2026-06-29,
 * sprint-490 active 78%).
 *
 * V0 design: all operations return identity or noop stubs. Enables code to pass type
 * checks while VPP integration is deferred. No Side effects, no cryptographic guarantees.
 *
 * Reference: S0 § cross-spec invariants X-1 (isolation), X-3 (crypto-shredding);
 * VPP Phase roadmap: draft-vauban-privacy-protocol-00 + integration plan TBD.
 */
/**
 * RevelationMask — declarative specification of which fields should be exposed
 * during a privacy-respecting operation.
 */
export interface RevelationMask {
    readonly public_fields: string[];
    readonly private_fields: string[];
    readonly conditional?: Array<{
        readonly field: string;
        readonly condition: string;
    }>;
}
export interface ZkProofInput {
    readonly proof_data: unknown;
    readonly public_inputs: unknown;
    readonly scheme?: string;
}
export interface VerifyResult {
    readonly valid: boolean;
    readonly reason?: string;
    readonly confidence?: number;
}
export interface Commitment {
    readonly value: unknown;
    readonly salt?: string;
    readonly index?: number;
}
export interface SmtResult {
    readonly smt_root: string;
    readonly leaf_index: number;
    readonly version: number;
    readonly proof?: unknown;
}
export interface PrivacyContext {
    readonly user_id?: string;
    readonly tenant_id?: string;
    readonly role?: string;
    readonly jurisdiction?: string;
    readonly metadata?: Record<string, unknown>;
}
/**
 * PrivacyPort — V0 noop stub.
 *
 * All methods return identity values or noop results. Replaced by full VPP
 * implementation in Phase 2 (Stwo+ML-KEM+viewing-key+SMT+cross-domain).
 *
 * Usage:
 *   const priv = new NoopPrivacyAdapter();
 *   const revealed = await priv.applyMask(data, mask, ctx); // data unchanged V0
 *   const vk = await priv.verifyZkProof(proof, ctx); // {valid: false, reason: 'noop_v0'}
 */
export interface PrivacyPort {
    /**
     * Apply a revelation mask to payload (V0: returns payload unchanged).
     *
     * Phase 2+: will implement field-level hiding via ZK commitments or viewing keys.
     *
     * @param payload input object or data structure
     * @param mask specification of which fields are public/private/conditional
     * @param ctx privacy context (user, tenant, role, jurisdiction)
     * @returns masked payload (V0: unchanged)
     */
    applyMask(payload: unknown, mask: RevelationMask, ctx: PrivacyContext): Promise<unknown>;
    /**
     * Verify a zero-knowledge proof (V0: always returns invalid with 'noop_v0' reason).
     *
     * Phase 2+: will implement Stwo proof verification against public inputs.
     *
     * @param proof ZK proof object (scheme TBD, likely Stwo)
     * @param ctx privacy context
     * @returns { valid: false, reason: 'noop_v0' } in V0
     */
    verifyZkProof(proof: ZkProofInput, ctx: PrivacyContext): Promise<VerifyResult>;
    /**
     * Commit value to sparse merkle tree (V0: returns deterministic mock root).
     *
     * Phase 2+: will implement full SMT with Poseidon hashing and viewing keys.
     *
     * @param commitment value or hash to commit
     * @param ctx privacy context
     * @returns mock SMT root (V0: deterministic, no cryptographic guarantee)
     */
    commitToSmt(commitment: Commitment, ctx: PrivacyContext): Promise<SmtResult>;
}
/**
 * NoopPrivacyAdapter — V0 stub implementation of PrivacyPort.
 *
 * All methods return identity values or noop results. Enables type-safe code
 * while VPP integration is deferred to Phase 2.
 *
 * Documentation: "V0 stub — replaced by VPP integration in Phase 2
 * (Stwo+ML-KEM+viewing key+SMT+cross-domain)."
 *
 * Usage:
 *   const adapter = new NoopPrivacyAdapter();
 *   const data = { secret: 'hidden', public: 'visible' };
 *   const masked = await adapter.applyMask(data, mask, ctx);
 *   // masked === data (unchanged in V0)
 */
export declare class NoopPrivacyAdapter implements PrivacyPort {
    applyMask(payload: unknown, _mask: RevelationMask, _ctx: PrivacyContext): Promise<unknown>;
    verifyZkProof(_proof: ZkProofInput, _ctx: PrivacyContext): Promise<VerifyResult>;
    commitToSmt(commitment: Commitment, _ctx: PrivacyContext): Promise<SmtResult>;
    /**
     * Compute a deterministic mock SMT root (V0 only).
     * Purely for testing — no cryptographic guarantee.
     */
    private computeMockRoot;
}
/**
 * PrivacyNoopWarning — logged when V0 noop operations are used.
 * Not thrown as an exception (non-blocking), but logged for observability.
 */
export declare class PrivacyNoopWarning extends Error {
    readonly operation: string;
    constructor(message: string, operation: string);
}
//# sourceMappingURL=privacy.d.ts.map