import { z } from "zod";
/**
 * The charter kinds. The first three are CHANNEL-PURE ESTIMATORS of a subsystem's
 * telos — each fed a disjoint evidence channel (blindness is a property of the
 * INPUT packet, never an instruction), held un-merged and mined for their pairwise
 * deltas. The deltas stay the primary product; the miner's triangulated telos is a
 * downstream ESTIMATE (a lead the owner reacts to), never a reconciliation.
 * - `stated`: testimony — docs + extracted comments (what the authors SAY).
 * - `structural`: intent frozen into organization — file tree / exports /
 *   signatures / names / import graph; no bodies, no docs, no comments.
 * - `revealed`: behavior — comment-stripped code bodies (what the code DOES).
 * - `true`: the "shining city" ideal, possibly inexpressible and the user may be
 *   unaware of it. Nominatable, never assertable (True-charter gate in
 *   validation/charterGate.ts); nominated by the delta miner DOWNSTREAM of
 *   triangulation, at the `deepest` ceiling only — never an extraction lane.
 */
export declare const CharterKindSchema: z.ZodEnum<["stated", "structural", "revealed", "true"]>;
export type CharterKind = z.infer<typeof CharterKindSchema>;
/**
 * Source confidence of a charter. Defined SEPARATELY from `FindingConfidence`
 * even though the enum values coincide today: the semantics differ (charter-source
 * strength vs finding strength) and coupling them would let a change to one
 * silently move the other. A `low`-confidence charter downgrades any dependent
 * review to "flag for human intent input, never opine" (charterReviewDisposition).
 */
export declare const CharterConfidenceSchema: z.ZodEnum<["high", "medium", "low"]>;
export type CharterConfidence = z.infer<typeof CharterConfidenceSchema>;
/**
 * Where a charter's purpose claim comes from, so a delta is adjudicable — each side
 * of a delta must be attributable. `ref` points at the source (a doc path, an
 * intent-checkpoint field, a component id); `quote` is the optional verbatim
 * evidence. Grounding that `ref` actually exists on disk is a Phase-C gate, not
 * enforced here.
 */
export declare const CharterProvenanceSchema: z.ZodObject<{
    kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
    ref: z.ZodString;
    quote: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
    ref: string;
    quote?: string | undefined;
}, {
    kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
    ref: string;
    quote?: string | undefined;
}>;
export type CharterProvenance = z.infer<typeof CharterProvenanceSchema>;
/**
 * A single charter. `purpose` MUST be stated in telos terms ("the audit pipeline
 * exists so maintainers can act on trustworthy findings"), never mechanism
 * ("it builds a graph") — a charter that restates the code collapses the
 * delta against the impl to zero and the review can never find under-delivery.
 *
 * `nominated_alternative` + `nominated_cost` are the falsifiable-or-drop payload of a
 * `true` charter (a concrete alternative + a concrete cost the user seems to pay
 * unaware — "Quicken exists; you're rebuilding a worse one"). They are optional in
 * the schema and REQUIRED-IFF-`kind==="true"` at the validator layer
 * (applyTrueCharterGate): a discriminated union here would fragment the array embed
 * on the intent checkpoint, and the design wants the gate to be a droppable runtime
 * check, not a parse failure.
 */
export declare const CharterSchema: z.ZodObject<{
    charter_id: z.ZodString;
    kind: z.ZodEnum<["stated", "structural", "revealed", "true"]>;
    /** Purpose in telos terms, never mechanism. */
    purpose: z.ZodString;
    /** May be `[]` for a `true` nomination (the ideal cites no source). */
    provenance: z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<["doc", "intent_checkpoint", "user_feedback", "code", "comment", "inferred"]>;
        ref: z.ZodString;
        quote: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
        ref: string;
        quote?: string | undefined;
    }, {
        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
        ref: string;
        quote?: string | undefined;
    }>, "many">;
    confidence: z.ZodEnum<["high", "medium", "low"]>;
    /** `true`-charter gate: the concrete better alternative it nominates. */
    nominated_alternative: z.ZodOptional<z.ZodString>;
    /** `true`-charter gate: the concrete cost the user seems to pay unaware. */
    nominated_cost: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    confidence: "high" | "low" | "medium";
    kind: "stated" | "structural" | "revealed" | "true";
    charter_id: string;
    purpose: string;
    provenance: {
        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
        ref: string;
        quote?: string | undefined;
    }[];
    nominated_alternative?: string | undefined;
    nominated_cost?: string | undefined;
}, {
    confidence: "high" | "low" | "medium";
    kind: "stated" | "structural" | "revealed" | "true";
    charter_id: string;
    purpose: string;
    provenance: {
        kind: "code" | "doc" | "intent_checkpoint" | "user_feedback" | "comment" | "inferred";
        ref: string;
        quote?: string | undefined;
    }[];
    nominated_alternative?: string | undefined;
    nominated_cost?: string | undefined;
}>;
export type Charter = z.infer<typeof CharterSchema>;
/**
 * A goal-DAG node. `premise_height` is an integer (0 = the telos, higher = closer to
 * a leaf mechanism), NEVER a fixed L0/L1/L2 enum — telos depth is EMERGENT (it falls
 * out of stable-across-scale decomposition), so mandating levels would hardcode the
 * thing the design rejects.
 */
export declare const GoalNodeSchema: z.ZodObject<{
    node_id: z.ZodString;
    premise_height: z.ZodNumber;
    statement: z.ZodString;
}, "strict", z.ZodTypeAny, {
    statement: string;
    node_id: string;
    premise_height: number;
}, {
    statement: string;
    node_id: string;
    premise_height: number;
}>;
export type GoalNode = z.infer<typeof GoalNodeSchema>;
/**
 * A goal-DAG edge: `from` (the child goal) serves `to` (its parent goal). Goals form
 * a DAG, not a tree — a node may serve multiple parents.
 */
export declare const GoalEdgeSchema: z.ZodObject<{
    from: z.ZodString;
    to: z.ZodString;
}, "strict", z.ZodTypeAny, {
    from: string;
    to: string;
}, {
    from: string;
    to: string;
}>;
export type GoalEdge = z.infer<typeof GoalEdgeSchema>;
/** The goal DAG (nodes + edges). Multi-parent nodes are legal by construction. */
export declare const GoalGraphSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        node_id: z.ZodString;
        premise_height: z.ZodNumber;
        statement: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        statement: string;
        node_id: string;
        premise_height: number;
    }, {
        statement: string;
        node_id: string;
        premise_height: number;
    }>, "many">;
    edges: z.ZodArray<z.ZodObject<{
        from: z.ZodString;
        to: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        from: string;
        to: string;
    }, {
        from: string;
        to: string;
    }>, "many">;
}, "strict", z.ZodTypeAny, {
    nodes: {
        statement: string;
        node_id: string;
        premise_height: number;
    }[];
    edges: {
        from: string;
        to: string;
    }[];
}, {
    nodes: {
        statement: string;
        node_id: string;
        premise_height: number;
    }[];
    edges: {
        from: string;
        to: string;
    }[];
}>;
export type GoalGraph = z.infer<typeof GoalGraphSchema>;
/**
 * The CEILING meta-intent (control-surface dial #2): how far up the premise stack a
 * finding may reach. This is the consent axis, captured at `intent_checkpoint`, NOT a
 * CLI flag — the top rung is the tool telling the user to abandon/rescope, so it
 * requires explicit opt-in:
 * - `shallow` — leaf + contract findings, Stated−Revealed drift (low blast).
 * - `deep` — charter-deltas, smeared-purpose, accidental-cluster findings (mid–high).
 * - `deepest` — Revealed−True / Stated−True provocations (max blast); `explicit_opt_in`.
 */
export declare const CeilingSchema: z.ZodObject<{
    rung: z.ZodEnum<["shallow", "deep", "deepest"]>;
    explicit_opt_in: z.ZodOptional<z.ZodBoolean>;
}, "strict", z.ZodTypeAny, {
    rung: "shallow" | "deep" | "deepest";
    explicit_opt_in?: boolean | undefined;
}, {
    rung: "shallow" | "deep" | "deepest";
    explicit_opt_in?: boolean | undefined;
}>;
export type Ceiling = z.infer<typeof CeilingSchema>;
/**
 * A routed pairwise charter delta — the product of the overlay-and-delta operator at
 * the charter layer (produced in Phase C). `pair` is a SYMMETRIC tuple of the two
 * charter kinds compared: the design forbids anointing any single estimator as
 * ground truth, so a delta is never modeled as `{ from: stated, to: X }`. Each
 * channel PAIR has one defined meaning; `routed_to` names who acts on it (a
 * low-confidence side forces `human` regardless of kind — gateCharterDelta):
 * - `doc_rot` (stated ↔ structural: testimony vs organization — doc rot / naming
 *   drift) → `remediator`.
 * - `says_does_drift` (stated ↔ revealed: testimony vs behavior) → `remediator`.
 * - `architecture_betrayal` (structural ↔ revealed: the organization's promise vs
 *   what the implementation actually does) → `clarification` (which governs?).
 * - `wrong_goal` (any estimator ↔ true) → `human` (provocation only; `deepest`).
 */
export declare const CharterDeltaSchema: z.ZodObject<{
    delta_id: z.ZodString;
    pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
    kind: z.ZodEnum<["doc_rot", "says_does_drift", "architecture_betrayal", "wrong_goal"]>;
    routed_to: z.ZodEnum<["remediator", "clarification", "human"]>;
    summary: z.ZodString;
    /**
     * The subsystem this delta was mined in. `delta_id` is OPAQUE — the assembler
     * mints it with a content-derived discriminator when one subsystem carries two
     * deltas on the same channel pair — so the originating node is carried as its
     * own field and never recovered by parsing the id.
     */
    node_id: z.ZodOptional<z.ZodString>;
    /** Present when `node_id` is linked into the mined goal graph. */
    goal_node_id: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    kind: "doc_rot" | "says_does_drift" | "architecture_betrayal" | "wrong_goal";
    summary: string;
    delta_id: string;
    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
    routed_to: "remediator" | "clarification" | "human";
    node_id?: string | undefined;
    goal_node_id?: string | undefined;
}, {
    kind: "doc_rot" | "says_does_drift" | "architecture_betrayal" | "wrong_goal";
    summary: string;
    delta_id: string;
    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
    routed_to: "remediator" | "clarification" | "human";
    node_id?: string | undefined;
    goal_node_id?: string | undefined;
}>;
export type CharterDelta = z.infer<typeof CharterDeltaSchema>;
/**
 * A delta as the Phase-C ASSEMBLER emits it — `node_id` required. The identity
 * fields are optional on `CharterDelta` because the type also describes a delta
 * mid-assembly (the gate operates on one before the register exists), but every
 * delta that reaches the persisted register carries its node, so the register
 * declares this narrower shape and consumers read the field instead of parsing
 * `delta_id`.
 */
export interface StampedCharterDelta extends CharterDelta {
    node_id: string;
}
/**
 * One node of a kind's self-organized leveled teleology. The lane organizes its
 * OWN view of the repo's purposes — `premise_height` is the emergent level
 * (0 = the telos, higher = closer to a leaf mechanism; an integer, NEVER a fixed
 * L0/L1/L2 enum), and `files` is the node's FILE SCOPE: content-derived join keys
 * no agent can mangle. The tool joins teleologies to each other and to the
 * decomposition hint mechanically by file-set overlap (assembleCharters).
 */
export declare const TeleologyNodeSchema: z.ZodObject<{
    /** Purpose in telos terms, never mechanism (same discipline as `Charter`). */
    purpose: z.ZodString;
    /** Emergent level: 0 = the telos, higher = nearer a leaf mechanism. */
    premise_height: z.ZodNumber;
    /** The node's file scope — the join key. At least one repo-relative path. */
    files: z.ZodArray<z.ZodString, "many">;
}, "strict", z.ZodTypeAny, {
    files: string[];
    purpose: string;
    premise_height: number;
}, {
    files: string[];
    purpose: string;
    premise_height: number;
}>;
export type TeleologyNode = z.infer<typeof TeleologyNodeSchema>;
/**
 * The delta miner's TRIANGULATED TELOS for one subsystem — a unified opinion the
 * owner reacts to, distilled from the three blind estimators. A LEAD, never a
 * reconciliation: the charters stay held un-merged, the deltas stay the primary
 * product, and no consumer may treat this as ground truth (the spec's
 * "never reconciled into one truth" boundary; the rejected thing is a merge that
 * DESTROYS the deltas, and this preserves them).
 */
export declare const TriangulatedTelosSchema: z.ZodObject<{
    /** The subsystem (joined unit) this estimate belongs to. */
    node_id: z.ZodString;
    /** The unified best-estimate telos, in telos terms. */
    telos: z.ZodString;
    confidence: z.ZodEnum<["high", "medium", "low"]>;
}, "strict", z.ZodTypeAny, {
    confidence: "high" | "low" | "medium";
    node_id: string;
    telos: string;
}, {
    confidence: "high" | "low" | "medium";
    node_id: string;
    telos: string;
}>;
export type TriangulatedTelos = z.infer<typeof TriangulatedTelosSchema>;
/**
 * Tool-computed disagreement density: how many deltas one subsystem carries per
 * channel pair — the quantitative surface for "which parts of the triangulation
 * need clarification." Deterministic (counted at assembly), never host-supplied.
 */
export declare const ChannelDisagreementSchema: z.ZodObject<{
    node_id: z.ZodString;
    pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
    count: z.ZodNumber;
}, "strict", z.ZodTypeAny, {
    node_id: string;
    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
    count: number;
}, {
    node_id: string;
    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
    count: number;
}>;
export type ChannelDisagreement = z.infer<typeof ChannelDisagreementSchema>;
/**
 * How answerable a charter question is — the axes the VOI ranking scores. A
 * `blast_radius` is how far up the goal DAG the answer ripples (goals are a DAG,
 * not a tree, so one answer can force reframes on multiple parents); a
 * `cascade_count` is how many other still-open deltas the answer is expected to
 * settle. High on both = highest value-of-information (resolve it first).
 */
export declare const ClarificationValueSchema: z.ZodObject<{
    /** How far up the goal DAG the fix ripples (0 = leaf). Priority AND risk. */
    blast_radius: z.ZodNumber;
    /** How many other open deltas this answer is expected to cascade-settle. */
    cascade_count: z.ZodNumber;
}, "strict", z.ZodTypeAny, {
    blast_radius: number;
    cascade_count: number;
}, {
    blast_radius: number;
    cascade_count: number;
}>;
export type ClarificationValue = z.infer<typeof ClarificationValueSchema>;
/**
 * A single charter-alignment question — the audit-side ClarificationRequest,
 * sourced from a routed CharterDelta. `options` are SYMMETRIC (any of the four
 * charters may move, including Stated; "leave open" is a first-class answer), so a
 * question never silently anoints Stated as ground truth. `value` carries the
 * blast-radius + cascade estimate the VOI queue ranks on. `answer` is set once the
 * user (or the autonomous zero-attention mode) resolves it.
 */
export declare const CharterClarificationAnswerSchema: z.ZodEnum<["this_side_wins", "that_side_wins", "rewrite_both", "leave_open"]>;
export type CharterClarificationAnswer = z.infer<typeof CharterClarificationAnswerSchema>;
export declare const CharterClarificationRequestSchema: z.ZodObject<{
    /** Stable id, derived from the source delta (`${delta_id}:q`). */
    request_id: z.ZodString;
    /** The routed delta this question triangulates. */
    delta_id: z.ZodString;
    /** The subsystem the delta belongs to (for grouping + reporting). */
    node_id: z.ZodString;
    /** The symmetric charter pair in tension. */
    pair: z.ZodTuple<[z.ZodEnum<["stated", "structural", "revealed", "true"]>, z.ZodEnum<["stated", "structural", "revealed", "true"]>], null>;
    /** The decidable question ("code optimizes X, docs say Y — which governs?"). */
    question: z.ZodString;
    /** The VOI axes this question is ranked on. */
    value: z.ZodObject<{
        /** How far up the goal DAG the fix ripples (0 = leaf). Priority AND risk. */
        blast_radius: z.ZodNumber;
        /** How many other open deltas this answer is expected to cascade-settle. */
        cascade_count: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        blast_radius: number;
        cascade_count: number;
    }, {
        blast_radius: number;
        cascade_count: number;
    }>;
    /**
     * Whether this question is CLEARED for the interactive human channel or must
     * only be written as a finding. A high-blast question that has not cleared the
     * risk gate's higher adversarial bar (or any question under zero attention) is
     * `finding_only`. `interactive` questions form the VOI queue the user answers.
     */
    disposition: z.ZodEnum<["interactive", "finding_only"]>;
    /** Resolved answer (symmetric); absent while the question is still open. */
    answer: z.ZodOptional<z.ZodEnum<["this_side_wins", "that_side_wins", "rewrite_both", "leave_open"]>>;
}, "strict", z.ZodTypeAny, {
    value: {
        blast_radius: number;
        cascade_count: number;
    };
    node_id: string;
    delta_id: string;
    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
    request_id: string;
    question: string;
    disposition: "interactive" | "finding_only";
    answer?: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open" | undefined;
}, {
    value: {
        blast_radius: number;
        cascade_count: number;
    };
    node_id: string;
    delta_id: string;
    pair: ["stated" | "structural" | "revealed" | "true", "stated" | "structural" | "revealed" | "true"];
    request_id: string;
    question: string;
    disposition: "interactive" | "finding_only";
    answer?: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open" | undefined;
}>;
export type CharterClarificationRequest = z.infer<typeof CharterClarificationRequestSchema>;
//# sourceMappingURL=charter.d.ts.map