import { z } from 'zod';

declare const KNOWLEDGE_SCHEMA_VERSION: 1;
declare const KNOWLEDGE_CONTENT_HASH_ALGO: "sha256-normalized-v1";
declare const ProvenanceSchema: z.ZodEnum<{
    proposed: "proposed";
    observed: "observed";
    declared: "declared";
}>;
type Provenance = z.infer<typeof ProvenanceSchema>;
declare const FindingStatusSchema: z.ZodEnum<{
    "not-analyzed": "not-analyzed";
    confirmed: "confirmed";
    undocumented: "undocumented";
    "stale-or-unverified": "stale-or-unverified";
    conflict: "conflict";
    unresolved: "unresolved";
}>;
type FindingStatus = z.infer<typeof FindingStatusSchema>;
declare const DiagnosticSeveritySchema: z.ZodEnum<{
    error: "error";
    off: "off";
    info: "info";
    warn: "warn";
}>;
type DiagnosticSeverity = z.infer<typeof DiagnosticSeveritySchema>;
declare const EvidenceSourceSchema: z.ZodEnum<{
    agent: "agent";
    documentation: "documentation";
    code: "code";
    configuration: "configuration";
    derived: "derived";
}>;
declare const EvidenceSchema: z.ZodObject<{
    source: z.ZodEnum<{
        agent: "agent";
        documentation: "documentation";
        code: "code";
        configuration: "configuration";
        derived: "derived";
    }>;
    path: z.ZodString;
    lineStart: z.ZodOptional<z.ZodNumber>;
    lineEnd: z.ZodOptional<z.ZodNumber>;
    contentHash: z.ZodOptional<z.ZodString>;
    context: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
type Evidence = z.infer<typeof EvidenceSchema>;
declare const CoverageSchema: z.ZodObject<{
    analyzer: z.ZodString;
    analyzerVersion: z.ZodOptional<z.ZodString>;
    scope: z.ZodString;
    status: z.ZodEnum<{
        complete: "complete";
        partial: "partial";
        "not-analyzed": "not-analyzed";
        "not-applicable": "not-applicable";
    }>;
    reason: z.ZodOptional<z.ZodString>;
    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<{
            agent: "agent";
            documentation: "documentation";
            code: "code";
            configuration: "configuration";
            derived: "derived";
        }>;
        path: z.ZodString;
        lineStart: z.ZodOptional<z.ZodNumber>;
        lineEnd: z.ZodOptional<z.ZodNumber>;
        contentHash: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
}, z.core.$strict>;
type Coverage = z.infer<typeof CoverageSchema>;
declare const ProjectIdentitySchema: z.ZodObject<{
    name: z.ZodString;
    root: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
declare const EntitySchema: z.ZodObject<{
    id: z.ZodString;
    kind: z.ZodString;
    name: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
    provenance: z.ZodEnum<{
        proposed: "proposed";
        observed: "observed";
        declared: "declared";
    }>;
    evidence: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<{
            agent: "agent";
            documentation: "documentation";
            code: "code";
            configuration: "configuration";
            derived: "derived";
        }>;
        path: z.ZodString;
        lineStart: z.ZodOptional<z.ZodNumber>;
        lineEnd: z.ZodOptional<z.ZodNumber>;
        contentHash: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strict>;
type KnowledgeEntity = z.infer<typeof EntitySchema>;
declare const RelationSchema: z.ZodObject<{
    id: z.ZodString;
    kind: z.ZodString;
    from: z.ZodString;
    to: z.ZodString;
    discriminator: z.ZodOptional<z.ZodString>;
    provenance: z.ZodEnum<{
        proposed: "proposed";
        observed: "observed";
        declared: "declared";
    }>;
    evidence: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<{
            agent: "agent";
            documentation: "documentation";
            code: "code";
            configuration: "configuration";
            derived: "derived";
        }>;
        path: z.ZodString;
        lineStart: z.ZodOptional<z.ZodNumber>;
        lineEnd: z.ZodOptional<z.ZodNumber>;
        contentHash: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strict>;
type KnowledgeRelation = z.infer<typeof RelationSchema>;
declare const DiscoverySnapshotV1Schema: z.ZodObject<{
    contentHashAlgo: z.ZodEnum<{
        "sha256-semantic-v1": "sha256-semantic-v1";
        "sha256-normalized-v1": "sha256-normalized-v1";
    }>;
    entities: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodString;
        name: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
        provenance: z.ZodEnum<{
            proposed: "proposed";
            observed: "observed";
            declared: "declared";
        }>;
        evidence: z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strict>>;
    relations: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodString;
        from: z.ZodString;
        to: z.ZodString;
        discriminator: z.ZodOptional<z.ZodString>;
        provenance: z.ZodEnum<{
            proposed: "proposed";
            observed: "observed";
            declared: "declared";
        }>;
        evidence: z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strict>>;
    coverage: z.ZodArray<z.ZodObject<{
        analyzer: z.ZodString;
        analyzerVersion: z.ZodOptional<z.ZodString>;
        scope: z.ZodString;
        status: z.ZodEnum<{
            complete: "complete";
            partial: "partial";
            "not-analyzed": "not-analyzed";
            "not-applicable": "not-applicable";
        }>;
        reason: z.ZodOptional<z.ZodString>;
        evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    project: z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    sourceRevision: z.ZodString;
    sourceRevisionKind: z.ZodEnum<{
        git: "git";
        content: "content";
    }>;
    configurationHash: z.ZodString;
    pipelineVersion: z.ZodString;
    analyzerVersions: z.ZodRecord<z.ZodString, z.ZodString>;
    type: z.ZodLiteral<"discovery-snapshot">;
}, z.core.$strict>;
type DiscoverySnapshotV1 = z.infer<typeof DiscoverySnapshotV1Schema>;
declare const DiagnosticSchema: z.ZodObject<{
    id: z.ZodString;
    code: z.ZodString;
    status: z.ZodEnum<{
        "not-analyzed": "not-analyzed";
        confirmed: "confirmed";
        undocumented: "undocumented";
        "stale-or-unverified": "stale-or-unverified";
        conflict: "conflict";
        unresolved: "unresolved";
    }>;
    severity: z.ZodEnum<{
        error: "error";
        off: "off";
        info: "info";
        warn: "warn";
    }>;
    message: z.ZodString;
    evidence: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<{
            agent: "agent";
            documentation: "documentation";
            code: "code";
            configuration: "configuration";
            derived: "derived";
        }>;
        path: z.ZodString;
        lineStart: z.ZodOptional<z.ZodNumber>;
        lineEnd: z.ZodOptional<z.ZodNumber>;
        contentHash: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    entityIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    relationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    documentationUpdate: z.ZodOptional<z.ZodLiteral<"updated-in-this-change">>;
    priority: z.ZodOptional<z.ZodLiteral<"low">>;
    changedDescendantPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
    remediation: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
type KnowledgeDiagnostic = z.infer<typeof DiagnosticSchema>;
declare const ReconciliationReportV1Schema: z.ZodObject<{
    contentHashAlgo: z.ZodEnum<{
        "sha256-semantic-v1": "sha256-semantic-v1";
        "sha256-normalized-v1": "sha256-normalized-v1";
    }>;
    snapshotHash: z.ZodString;
    diagnostics: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        code: z.ZodString;
        status: z.ZodEnum<{
            "not-analyzed": "not-analyzed";
            confirmed: "confirmed";
            undocumented: "undocumented";
            "stale-or-unverified": "stale-or-unverified";
            conflict: "conflict";
            unresolved: "unresolved";
        }>;
        severity: z.ZodEnum<{
            error: "error";
            off: "off";
            info: "info";
            warn: "warn";
        }>;
        message: z.ZodString;
        evidence: z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        entityIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
        relationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
        documentationUpdate: z.ZodOptional<z.ZodLiteral<"updated-in-this-change">>;
        priority: z.ZodOptional<z.ZodLiteral<"low">>;
        changedDescendantPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
        remediation: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    summary: z.ZodObject<{
        entityCount: z.ZodNumber;
        relationCount: z.ZodNumber;
        diagnosticCount: z.ZodNumber;
        scope: z.ZodOptional<z.ZodEnum<{
            file: "file";
            module: "module";
            area: "area";
            package: "package";
        }>>;
        requiredRelationKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
        requiredRelationTargets: z.ZodOptional<z.ZodEnum<{
            all: "all";
            internal: "internal";
        }>>;
        diagnosticsByCode: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        diagnosticsByStatus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        documentation: z.ZodOptional<z.ZodObject<{
            documentCount: z.ZodNumber;
            documentedDocumentCount: z.ZodNumber;
            documentClassificationCounts: z.ZodRecord<z.ZodString, z.ZodNumber>;
            documentedDocumentClassificationCounts: z.ZodRecord<z.ZodString, z.ZodNumber>;
            packageCount: z.ZodNumber;
            packageStatus: z.ZodObject<{
                fresh: z.ZodNumber;
                stale: z.ZodNumber;
                missing: z.ZodNumber;
                unverified: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    project: z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    sourceRevision: z.ZodString;
    sourceRevisionKind: z.ZodEnum<{
        git: "git";
        content: "content";
    }>;
    configurationHash: z.ZodString;
    pipelineVersion: z.ZodString;
    analyzerVersions: z.ZodRecord<z.ZodString, z.ZodString>;
    type: z.ZodLiteral<"reconciliation-report">;
}, z.core.$strict>;
type ReconciliationReportV1 = z.infer<typeof ReconciliationReportV1Schema>;
declare const WorkflowStateSchema: z.ZodEnum<{
    proposed: "proposed";
    analyzed: "analyzed";
    stale: "stale";
    created: "created";
    discovering: "discovering";
    compared: "compared";
    "awaiting-agent": "awaiting-agent";
    "awaiting-approval": "awaiting-approval";
    validating: "validating";
    delivered: "delivered";
    failed: "failed";
    cancelled: "cancelled";
    superseded: "superseded";
}>;
type WorkflowState = z.infer<typeof WorkflowStateSchema>;
declare const WorkflowStepSchema: z.ZodObject<{
    name: z.ZodString;
    status: z.ZodEnum<{
        pending: "pending";
        failed: "failed";
        running: "running";
        completed: "completed";
        skipped: "skipped";
    }>;
    inputHash: z.ZodString;
    outputHash: z.ZodOptional<z.ZodString>;
    artifactRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strict>;
type WorkflowStep = z.infer<typeof WorkflowStepSchema>;
declare const WorkflowTransitionSchema: z.ZodObject<{
    from: z.ZodNullable<z.ZodEnum<{
        proposed: "proposed";
        analyzed: "analyzed";
        stale: "stale";
        created: "created";
        discovering: "discovering";
        compared: "compared";
        "awaiting-agent": "awaiting-agent";
        "awaiting-approval": "awaiting-approval";
        validating: "validating";
        delivered: "delivered";
        failed: "failed";
        cancelled: "cancelled";
        superseded: "superseded";
    }>>;
    to: z.ZodEnum<{
        proposed: "proposed";
        analyzed: "analyzed";
        stale: "stale";
        created: "created";
        discovering: "discovering";
        compared: "compared";
        "awaiting-agent": "awaiting-agent";
        "awaiting-approval": "awaiting-approval";
        validating: "validating";
        delivered: "delivered";
        failed: "failed";
        cancelled: "cancelled";
        superseded: "superseded";
    }>;
    at: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
/** Optional identity envelope shared with AgentsKit runtime and Chat events. */
declare const CorrelationContextV1Schema: z.ZodObject<{
    operationId: z.ZodString;
    runId: z.ZodOptional<z.ZodString>;
    sessionId: z.ZodOptional<z.ZodString>;
    turnId: z.ZodOptional<z.ZodString>;
    actionId: z.ZodOptional<z.ZodString>;
    traceId: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
type CorrelationContextV1 = z.infer<typeof CorrelationContextV1Schema>;
declare const WorkflowRunV1Schema: z.ZodObject<{
    runId: z.ZodString;
    correlation: z.ZodOptional<z.ZodObject<{
        operationId: z.ZodString;
        runId: z.ZodOptional<z.ZodString>;
        sessionId: z.ZodOptional<z.ZodString>;
        turnId: z.ZodOptional<z.ZodString>;
        actionId: z.ZodOptional<z.ZodString>;
        traceId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    state: z.ZodEnum<{
        proposed: "proposed";
        analyzed: "analyzed";
        stale: "stale";
        created: "created";
        discovering: "discovering";
        compared: "compared";
        "awaiting-agent": "awaiting-agent";
        "awaiting-approval": "awaiting-approval";
        validating: "validating";
        delivered: "delivered";
        failed: "failed";
        cancelled: "cancelled";
        superseded: "superseded";
    }>;
    steps: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        status: z.ZodEnum<{
            pending: "pending";
            failed: "failed";
            running: "running";
            completed: "completed";
            skipped: "skipped";
        }>;
        inputHash: z.ZodString;
        outputHash: z.ZodOptional<z.ZodString>;
        artifactRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>>;
    transitions: z.ZodArray<z.ZodObject<{
        from: z.ZodNullable<z.ZodEnum<{
            proposed: "proposed";
            analyzed: "analyzed";
            stale: "stale";
            created: "created";
            discovering: "discovering";
            compared: "compared";
            "awaiting-agent": "awaiting-agent";
            "awaiting-approval": "awaiting-approval";
            validating: "validating";
            delivered: "delivered";
            failed: "failed";
            cancelled: "cancelled";
            superseded: "superseded";
        }>>;
        to: z.ZodEnum<{
            proposed: "proposed";
            analyzed: "analyzed";
            stale: "stale";
            created: "created";
            discovering: "discovering";
            compared: "compared";
            "awaiting-agent": "awaiting-agent";
            "awaiting-approval": "awaiting-approval";
            validating: "validating";
            delivered: "delivered";
            failed: "failed";
            cancelled: "cancelled";
            superseded: "superseded";
        }>;
        at: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    artifactRefs: z.ZodArray<z.ZodString>;
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    contentHashAlgo: z.ZodLiteral<"sha256-normalized-v1">;
    project: z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    sourceRevision: z.ZodString;
    sourceRevisionKind: z.ZodEnum<{
        git: "git";
        content: "content";
    }>;
    configurationHash: z.ZodString;
    pipelineVersion: z.ZodString;
    analyzerVersions: z.ZodRecord<z.ZodString, z.ZodString>;
    type: z.ZodLiteral<"workflow-run">;
}, z.core.$strict>;
type WorkflowRunV1 = z.infer<typeof WorkflowRunV1Schema>;
declare const ProposalOriginSchema: z.ZodObject<{
    kind: z.ZodEnum<{
        deterministic: "deterministic";
        "registry-agent": "registry-agent";
        manual: "manual";
    }>;
    id: z.ZodOptional<z.ZodString>;
    version: z.ZodOptional<z.ZodString>;
    provider: z.ZodOptional<z.ZodString>;
    model: z.ZodOptional<z.ZodString>;
    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strict>;
declare const AgentProposalV1Schema: z.ZodObject<{
    proposalId: z.ZodString;
    baseSnapshotHash: z.ZodString;
    baseReportHash: z.ZodString;
    baseDocumentationAuditHash: z.ZodOptional<z.ZodString>;
    relatedDiagnosticIds: z.ZodArray<z.ZodString>;
    rationale: z.ZodString;
    confidence: z.ZodNumber;
    evidence: z.ZodArray<z.ZodObject<{
        source: z.ZodEnum<{
            agent: "agent";
            documentation: "documentation";
            code: "code";
            configuration: "configuration";
            derived: "derived";
        }>;
        path: z.ZodString;
        lineStart: z.ZodOptional<z.ZodNumber>;
        lineEnd: z.ZodOptional<z.ZodNumber>;
        contentHash: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    intendedChanges: z.ZodArray<z.ZodString>;
    origin: z.ZodObject<{
        kind: z.ZodEnum<{
            deterministic: "deterministic";
            "registry-agent": "registry-agent";
            manual: "manual";
        }>;
        id: z.ZodOptional<z.ZodString>;
        version: z.ZodOptional<z.ZodString>;
        provider: z.ZodOptional<z.ZodString>;
        model: z.ZodOptional<z.ZodString>;
        capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>;
    checks: z.ZodArray<z.ZodString>;
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    contentHashAlgo: z.ZodLiteral<"sha256-normalized-v1">;
    project: z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    sourceRevision: z.ZodString;
    sourceRevisionKind: z.ZodEnum<{
        git: "git";
        content: "content";
    }>;
    configurationHash: z.ZodString;
    pipelineVersion: z.ZodString;
    analyzerVersions: z.ZodRecord<z.ZodString, z.ZodString>;
    type: z.ZodLiteral<"agent-proposal">;
}, z.core.$strict>;
type AgentProposalV1 = z.infer<typeof AgentProposalV1Schema>;
declare const FixProposalStatusSchema: z.ZodEnum<{
    proposed: "proposed";
    stale: "stale";
    failed: "failed";
    approved: "approved";
    rejected: "rejected";
    applied: "applied";
}>;
declare const AffectedFileSchema: z.ZodObject<{
    path: z.ZodString;
    contentHash: z.ZodString;
}, z.core.$strict>;
declare const FixChangeSchema: z.ZodObject<{
    path: z.ZodString;
    before: z.ZodString;
    after: z.ZodString;
}, z.core.$strict>;
type FixChange = z.infer<typeof FixChangeSchema>;
declare const FixProposalV1Schema: z.ZodObject<{
    proposalId: z.ZodString;
    baseRevision: z.ZodString;
    affectedFiles: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    changes: z.ZodOptional<z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        before: z.ZodString;
        after: z.ZodString;
    }, z.core.$strict>>>;
    preconditions: z.ZodArray<z.ZodString>;
    diff: z.ZodString;
    postconditions: z.ZodArray<z.ZodString>;
    approval: z.ZodOptional<z.ZodObject<{
        proposalHash: z.ZodString;
        approvedAt: z.ZodString;
        approvedBy: z.ZodString;
    }, z.core.$strict>>;
    status: z.ZodEnum<{
        proposed: "proposed";
        stale: "stale";
        failed: "failed";
        approved: "approved";
        rejected: "rejected";
        applied: "applied";
    }>;
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    contentHashAlgo: z.ZodLiteral<"sha256-normalized-v1">;
    project: z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    sourceRevision: z.ZodString;
    sourceRevisionKind: z.ZodEnum<{
        git: "git";
        content: "content";
    }>;
    configurationHash: z.ZodString;
    pipelineVersion: z.ZodString;
    analyzerVersions: z.ZodRecord<z.ZodString, z.ZodString>;
    type: z.ZodLiteral<"fix-proposal">;
}, z.core.$strict>;
type FixProposalV1 = z.infer<typeof FixProposalV1Schema>;
type KnowledgeArtifactV1 = DiscoverySnapshotV1 | ReconciliationReportV1 | WorkflowRunV1 | AgentProposalV1 | FixProposalV1;

declare const FindingV1Schema: z.ZodObject<{
    type: z.ZodLiteral<"finding">;
    schemaVersion: z.ZodLiteral<1>;
    id: z.ZodString;
    category: z.ZodString;
    assertion: z.ZodObject<{
        document: z.ZodString;
        key: z.ZodString;
    }, z.core.$strict>;
    evidenceHash: z.ZodString;
    status: z.ZodLazy<z.ZodEnum<{
        "not-analyzed": "not-analyzed";
        confirmed: "confirmed";
        undocumented: "undocumented";
        "stale-or-unverified": "stale-or-unverified";
        conflict: "conflict";
        unresolved: "unresolved";
    }>>;
    layer: z.ZodEnum<{
        L0: "L0";
        L1: "L1";
        L2: "L2";
    }>;
    confidence: z.ZodNumber;
    severity: z.ZodLazy<z.ZodEnum<{
        error: "error";
        off: "off";
        info: "info";
        warn: "warn";
    }>>;
    entities: z.ZodArray<z.ZodString>;
    evidence: z.ZodArray<z.ZodLazy<z.ZodObject<{
        source: z.ZodEnum<{
            agent: "agent";
            documentation: "documentation";
            code: "code";
            configuration: "configuration";
            derived: "derived";
        }>;
        path: z.ZodString;
        lineStart: z.ZodOptional<z.ZodNumber>;
        lineEnd: z.ZodOptional<z.ZodNumber>;
        contentHash: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
    routing: z.ZodEnum<{
        proposed: "proposed";
        excluded: "excluded";
        "routed-to-L2": "routed-to-L2";
        "pending-version": "pending-version";
    }>;
    documentationUpdate: z.ZodOptional<z.ZodLiteral<"updated-in-this-change">>;
    priority: z.ZodOptional<z.ZodLiteral<"low">>;
    changedDescendantPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
    generator: z.ZodOptional<z.ZodString>;
    coverage: z.ZodArray<z.ZodLazy<z.ZodObject<{
        analyzer: z.ZodString;
        analyzerVersion: z.ZodOptional<z.ZodString>;
        scope: z.ZodString;
        status: z.ZodEnum<{
            complete: "complete";
            partial: "partial";
            "not-analyzed": "not-analyzed";
            "not-applicable": "not-applicable";
        }>;
        reason: z.ZodOptional<z.ZodString>;
        evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>>;
    provenance: z.ZodObject<{
        repository: z.ZodString;
        revision: z.ZodString;
        configurationHash: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>;
type FindingV1 = z.infer<typeof FindingV1Schema>;
declare const DecisionV1Schema: z.ZodObject<{
    type: z.ZodLiteral<"decision">;
    schemaVersion: z.ZodLiteral<1>;
    target: z.ZodObject<{
        kind: z.ZodEnum<{
            remediation: "remediation";
            finding: "finding";
        }>;
        id: z.ZodString;
    }, z.core.$strict>;
    by: z.ZodString;
    reason: z.ZodEnum<{
        "not-a-divergence": "not-a-divergence";
        "wrong-fix": "wrong-fix";
        "code-should-change": "code-should-change";
        "out-of-scope": "out-of-scope";
    }>;
    evidenceHash: z.ZodString;
}, z.core.$strict>;
type DecisionV1 = z.infer<typeof DecisionV1Schema>;
declare const RegionEditSchema: z.ZodObject<{
    path: z.ZodString;
    range: z.ZodObject<{
        start: z.ZodNumber;
        end: z.ZodNumber;
    }, z.core.$strict>;
    expectedRegionHash: z.ZodString;
    original: z.ZodString;
    replacement: z.ZodString;
    anchors: z.ZodOptional<z.ZodObject<{
        before: z.ZodString;
        after: z.ZodString;
        search: z.ZodObject<{
            start: z.ZodNumber;
            end: z.ZodNumber;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    lineStart: z.ZodNumber;
    lineEnd: z.ZodNumber;
}, z.core.$strict>;
declare const RemediationV1Schema: z.ZodObject<{
    type: z.ZodLiteral<"remediation">;
    schemaVersion: z.ZodLiteral<1>;
    id: z.ZodString;
    findingId: z.ZodString;
    evidenceHash: z.ZodString;
    regionHashAlgo: z.ZodLiteral<"sha256-bytes-v1">;
    coordinates: z.ZodLiteral<"utf8-byte-half-open-v1">;
    baseRevision: z.ZodString;
    configurationHash: z.ZodString;
    edits: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        range: z.ZodObject<{
            start: z.ZodNumber;
            end: z.ZodNumber;
        }, z.core.$strict>;
        expectedRegionHash: z.ZodString;
        original: z.ZodString;
        replacement: z.ZodString;
        anchors: z.ZodOptional<z.ZodObject<{
            before: z.ZodString;
            after: z.ZodString;
            search: z.ZodObject<{
                start: z.ZodNumber;
                end: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        lineStart: z.ZodNumber;
        lineEnd: z.ZodNumber;
    }, z.core.$strict>>;
    diff: z.ZodString;
    status: z.ZodEnum<{
        proposed: "proposed";
        stale: "stale";
        superseded: "superseded";
        rejected: "rejected";
        "in-review": "in-review";
        merged: "merged";
    }>;
    binding: z.ZodObject<{
        revision: z.ZodString;
        evidenceHash: z.ZodString;
        configurationHash: z.ZodString;
        artifactHash: z.ZodString;
    }, z.core.$strict>;
    revalidation: z.ZodOptional<z.ZodObject<{
        fromRevision: z.ZodString;
        toRevision: z.ZodString;
        evidenceHash: z.ZodString;
        configurationHash: z.ZodString;
    }, z.core.$strict>>;
    approval: z.ZodOptional<z.ZodObject<{
        by: z.ZodString;
        bindingHash: z.ZodString;
    }, z.core.$strict>>;
    presentation: z.ZodOptional<z.ZodObject<{
        revision: z.ZodString;
        artifactHash: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
type RemediationV1 = z.infer<typeof RemediationV1Schema>;
type RegionEdit = z.infer<typeof RegionEditSchema>;

declare const KNOWLEDGE_ENTITY_SCHEMA_VERSION: 1;
declare const KnowledgeEntityEvidenceV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    kind: z.ZodLiteral<"document-region">;
    path: z.ZodString;
    lineStart: z.ZodNumber;
    lineEnd: z.ZodNumber;
    regionHash: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"commit">;
    sha: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"fact">;
    factId: z.ZodString;
}, z.core.$strict>], "kind">;
declare const KnowledgeEntityLinkV1Schema: z.ZodObject<{
    kind: z.ZodEnum<{
        "affected-path": "affected-path";
        "affected-fact": "affected-fact";
        "defines-symbol": "defines-symbol";
        supersedes: "supersedes";
        "superseded-by": "superseded-by";
    }>;
    target: z.ZodString;
    symbol: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
declare const KnowledgeEntityV1Schema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<1>;
    id: z.ZodString;
    kind: z.ZodEnum<{
        change: "change";
        decision: "decision";
        concept: "concept";
    }>;
    name: z.ZodString;
    aliases: z.ZodArray<z.ZodString>;
    evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"document-region">;
        path: z.ZodString;
        lineStart: z.ZodNumber;
        lineEnd: z.ZodNumber;
        regionHash: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"commit">;
        sha: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"fact">;
        factId: z.ZodString;
    }, z.core.$strict>], "kind">>;
    links: z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<{
            "affected-path": "affected-path";
            "affected-fact": "affected-fact";
            "defines-symbol": "defines-symbol";
            supersedes: "supersedes";
            "superseded-by": "superseded-by";
        }>;
        target: z.ZodString;
        symbol: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    status: z.ZodOptional<z.ZodString>;
    date: z.ZodOptional<z.ZodString>;
    conventional: z.ZodOptional<z.ZodObject<{
        type: z.ZodString;
        scope: z.ZodOptional<z.ZodString>;
        breaking: z.ZodBoolean;
    }, z.core.$strict>>;
}, z.core.$strict>;
declare const MemoryEntityRelationV1Schema: z.ZodObject<{
    kind: z.ZodLiteral<"memory-supports">;
    candidateId: z.ZodString;
    target: z.ZodString;
    evidence: z.ZodObject<{
        kind: z.ZodEnum<{
            path: "path";
            id: "id";
            alias: "alias";
        }>;
        value: z.ZodString;
        rawPath: z.ZodOptional<z.ZodString>;
        factHash: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>;
type MemoryEntityRelationV1 = z.infer<typeof MemoryEntityRelationV1Schema>;
declare const KnowledgeEntitiesV1Schema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<1>;
    entities: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<1>;
        id: z.ZodString;
        kind: z.ZodEnum<{
            change: "change";
            decision: "decision";
            concept: "concept";
        }>;
        name: z.ZodString;
        aliases: z.ZodArray<z.ZodString>;
        evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"document-region">;
            path: z.ZodString;
            lineStart: z.ZodNumber;
            lineEnd: z.ZodNumber;
            regionHash: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"commit">;
            sha: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"fact">;
            factId: z.ZodString;
        }, z.core.$strict>], "kind">>;
        links: z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<{
                "affected-path": "affected-path";
                "affected-fact": "affected-fact";
                "defines-symbol": "defines-symbol";
                supersedes: "supersedes";
                "superseded-by": "superseded-by";
            }>;
            target: z.ZodString;
            symbol: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        status: z.ZodOptional<z.ZodString>;
        date: z.ZodOptional<z.ZodString>;
        conventional: z.ZodOptional<z.ZodObject<{
            type: z.ZodString;
            scope: z.ZodOptional<z.ZodString>;
            breaking: z.ZodBoolean;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    memoryRelations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        kind: z.ZodLiteral<"memory-supports">;
        candidateId: z.ZodString;
        target: z.ZodString;
        evidence: z.ZodObject<{
            kind: z.ZodEnum<{
                path: "path";
                id: "id";
                alias: "alias";
            }>;
            value: z.ZodString;
            rawPath: z.ZodOptional<z.ZodString>;
            factHash: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>>>;
    coverage: z.ZodArray<z.ZodObject<{
        analyzer: z.ZodString;
        analyzerVersion: z.ZodOptional<z.ZodString>;
        scope: z.ZodString;
        status: z.ZodEnum<{
            complete: "complete";
            partial: "partial";
            "not-analyzed": "not-analyzed";
            "not-applicable": "not-applicable";
        }>;
        reason: z.ZodOptional<z.ZodString>;
        evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
}, z.core.$strict>;
type KnowledgeEntityV1 = z.infer<typeof KnowledgeEntityV1Schema>;
type KnowledgeEntityEvidenceV1 = z.infer<typeof KnowledgeEntityEvidenceV1Schema>;
type KnowledgeEntityLinkV1 = z.infer<typeof KnowledgeEntityLinkV1Schema>;
type KnowledgeEntitiesV1 = z.infer<typeof KnowledgeEntitiesV1Schema>;

declare const INDEX_SCHEMA_VERSION: 1;
declare const KnowledgeEntrySchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodString;
    title: z.ZodString;
    path: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    body: z.ZodOptional<z.ZodString>;
    links: z.ZodOptional<z.ZodArray<z.ZodString>>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
    contentHash: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
/**
 * Fingerprint of the repository files the index was built from. Freshness can then be checked by
 * re-hashing the inputs instead of rebuilding the whole index on every query.
 */
declare const RepositoryInputsSchema: z.ZodObject<{
    hash: z.ZodString;
    fileCount: z.ZodNumber;
    projectionVersion: z.ZodNumber;
    incomplete: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict>;
/**
 * How this index was prepared for ranking. Recorded so a ranking is reproducible: a different
 * stopword list or a different field weight produces a different artifact, visibly.
 */
declare const RetrievalMetadataSchema: z.ZodObject<{
    lexiconVersion: z.ZodNumber;
    weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
    params: z.ZodOptional<z.ZodObject<{
        k1: z.ZodNumber;
        b: z.ZodNumber;
    }, z.core.$strict>>;
}, z.core.$strict>;
/** Why a `reference-findings` gate failed; ADR 0025. */
declare const REFERENCE_FINDINGS_REASONS: readonly ["no-base", "base-unreadable", "base-invalid", "diff-unavailable", "pending"];
declare const IndexPublicationSchema: z.ZodObject<{
    pendingReferenceFindings: z.ZodObject<{
        override: z.ZodLiteral<"allow-pending-findings">;
        pendingCount: z.ZodOptional<z.ZodNumber>;
        baseRevision: z.ZodOptional<z.ZodString>;
        reason: z.ZodEnum<{
            "no-base": "no-base";
            "base-unreadable": "base-unreadable";
            "base-invalid": "base-invalid";
            "diff-unavailable": "diff-unavailable";
            pending: "pending";
        }>;
    }, z.core.$strict>;
}, z.core.$strict>;
declare const DocBridgeIndexV1Schema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    contentHashAlgo: z.ZodEnum<{
        "sha256-semantic-v1": "sha256-semantic-v1";
        "sha256-normalized-v1": "sha256-normalized-v1";
    }>;
    generatedAt: z.ZodOptional<z.ZodString>;
    project: z.ZodOptional<z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        url: z.ZodOptional<z.ZodString>;
        llms: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
    knowledge: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodString;
        title: z.ZodString;
        path: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        body: z.ZodOptional<z.ZodString>;
        links: z.ZodOptional<z.ZodArray<z.ZodString>>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
        contentHash: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    knowledgeEntities: z.ZodOptional<z.ZodObject<{
        schemaVersion: z.ZodLiteral<1>;
        entities: z.ZodArray<z.ZodObject<{
            schemaVersion: z.ZodLiteral<1>;
            id: z.ZodString;
            kind: z.ZodEnum<{
                change: "change";
                decision: "decision";
                concept: "concept";
            }>;
            name: z.ZodString;
            aliases: z.ZodArray<z.ZodString>;
            evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"document-region">;
                path: z.ZodString;
                lineStart: z.ZodNumber;
                lineEnd: z.ZodNumber;
                regionHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"commit">;
                sha: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fact">;
                factId: z.ZodString;
            }, z.core.$strict>], "kind">>;
            links: z.ZodArray<z.ZodObject<{
                kind: z.ZodEnum<{
                    "affected-path": "affected-path";
                    "affected-fact": "affected-fact";
                    "defines-symbol": "defines-symbol";
                    supersedes: "supersedes";
                    "superseded-by": "superseded-by";
                }>;
                target: z.ZodString;
                symbol: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
            status: z.ZodOptional<z.ZodString>;
            date: z.ZodOptional<z.ZodString>;
            conventional: z.ZodOptional<z.ZodObject<{
                type: z.ZodString;
                scope: z.ZodOptional<z.ZodString>;
                breaking: z.ZodBoolean;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        memoryRelations: z.ZodOptional<z.ZodArray<z.ZodObject<{
            kind: z.ZodLiteral<"memory-supports">;
            candidateId: z.ZodString;
            target: z.ZodString;
            evidence: z.ZodObject<{
                kind: z.ZodEnum<{
                    path: "path";
                    id: "id";
                    alias: "alias";
                }>;
                value: z.ZodString;
                rawPath: z.ZodOptional<z.ZodString>;
                factHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        coverage: z.ZodArray<z.ZodObject<{
            analyzer: z.ZodString;
            analyzerVersion: z.ZodOptional<z.ZodString>;
            scope: z.ZodString;
            status: z.ZodEnum<{
                complete: "complete";
                partial: "partial";
                "not-analyzed": "not-analyzed";
                "not-applicable": "not-applicable";
            }>;
            reason: z.ZodOptional<z.ZodString>;
            evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
                source: z.ZodEnum<{
                    agent: "agent";
                    documentation: "documentation";
                    code: "code";
                    configuration: "configuration";
                    derived: "derived";
                }>;
                path: z.ZodString;
                lineStart: z.ZodOptional<z.ZodNumber>;
                lineEnd: z.ZodOptional<z.ZodNumber>;
                contentHash: z.ZodOptional<z.ZodString>;
                context: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
    handoffs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        type: z.ZodLiteral<"agent-handoff">;
        checks: z.ZodArray<z.ZodString>;
        humanDoc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        startHere: z.ZodString;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        related: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            direction: z.ZodEnum<{
                imports: "imports";
                "imported-by": "imported-by";
            }>;
            strength: z.ZodNumber;
            evidence: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>>;
        budget: z.ZodOptional<z.ZodObject<{
            budgetTokens: z.ZodNumber;
            tokens: z.ZodObject<{
                total: z.ZodNumber;
                budget: z.ZodNumber;
                core: z.ZodNumber;
                sections: z.ZodRecord<z.ZodEnum<{
                    evidenceExcerpts: "evidenceExcerpts";
                    related: "related";
                    neighbours: "neighbours";
                    summaries: "summaries";
                }> & z.core.$partial, z.ZodNumber>;
            }, z.core.$strict>;
            fits: z.ZodBoolean;
            order: z.ZodArray<z.ZodEnum<{
                evidenceExcerpts: "evidenceExcerpts";
                related: "related";
                neighbours: "neighbours";
                summaries: "summaries";
            }>>;
            kept: z.ZodArray<z.ZodEnum<{
                evidenceExcerpts: "evidenceExcerpts";
                related: "related";
                neighbours: "neighbours";
                summaries: "summaries";
            }>>;
            dropped: z.ZodArray<z.ZodEnum<{
                evidenceExcerpts: "evidenceExcerpts";
                related: "related";
                neighbours: "neighbours";
                summaries: "summaries";
            }>>;
            tokenMethod: z.ZodLiteral<"approximate">;
        }, z.core.$strict>>;
        evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
            source: z.ZodEnum<{
                agent: "agent";
                documentation: "documentation";
                code: "code";
                configuration: "configuration";
                derived: "derived";
            }>;
            path: z.ZodString;
            lineStart: z.ZodOptional<z.ZodNumber>;
            lineEnd: z.ZodOptional<z.ZodNumber>;
            contentHash: z.ZodOptional<z.ZodString>;
            context: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        target: z.ZodObject<{
            type: z.ZodEnum<{
                module: "module";
                area: "area";
                package: "package";
                search: "search";
                document: "document";
                app: "app";
                screen: "screen";
                flow: "flow";
                component: "component";
                intent: "intent";
                change: "change";
            }>;
            id: z.ZodString;
            path: z.ZodOptional<z.ZodString>;
            group: z.ZodOptional<z.ZodString>;
            layer: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>;
        source: z.ZodString;
        readBeforeEditing: z.ZodArray<z.ZodString>;
        editRoots: z.ZodArray<z.ZodString>;
        bridge: z.ZodOptional<z.ZodObject<{
            humanDoc: z.ZodEnum<{
                linked: "linked";
                missing: "missing";
                external: "external";
            }>;
            action: z.ZodOptional<z.ZodString>;
            bootstrap: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        playbookPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        notes: z.ZodArray<z.ZodString>;
        explain: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
        caveats: z.ZodOptional<z.ZodObject<{
            pendingFindings: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                status: z.ZodString;
                routing: z.ZodEnum<{
                    proposed: "proposed";
                    excluded: "excluded";
                    "routed-to-L2": "routed-to-L2";
                    "pending-version": "pending-version";
                }>;
            }, z.core.$strict>>;
            analyzed: z.ZodArray<z.ZodObject<{
                repository: z.ZodString;
                revision: z.ZodString;
            }, z.core.$strict>>;
            coverage: z.ZodArray<z.ZodObject<{
                scope: z.ZodString;
                status: z.ZodEnum<{
                    complete: "complete";
                    partial: "partial";
                    "not-analyzed": "not-analyzed";
                    "not-applicable": "not-applicable";
                }>;
                reason: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        schemaVersion: z.ZodOptional<z.ZodLiteral<1>>;
    }, z.core.$strict>>>;
    lookup: z.ZodOptional<z.ZodObject<{
        packages: z.ZodArray<z.ZodString>;
        ownership: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            group: z.ZodOptional<z.ZodString>;
            layer: z.ZodOptional<z.ZodString>;
            purpose: z.ZodOptional<z.ZodString>;
            checks: z.ZodArray<z.ZodString>;
            checksSource: z.ZodOptional<z.ZodEnum<{
                default: "default";
                ownership: "ownership";
                frontmatter: "frontmatter";
                "package-scripts": "package-scripts";
            }>>;
            agentDoc: z.ZodOptional<z.ZodString>;
            humanDoc: z.ZodOptional<z.ZodString>;
            readme: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        intents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            id: z.ZodString;
            title: z.ZodString;
            paths: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>>;
        changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            id: z.ZodString;
            title: z.ZodString;
            startHere: z.ZodString;
            relatedPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
    inputs: z.ZodOptional<z.ZodObject<{
        hash: z.ZodString;
        fileCount: z.ZodNumber;
        projectionVersion: z.ZodNumber;
        incomplete: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    retrieval: z.ZodOptional<z.ZodObject<{
        lexiconVersion: z.ZodNumber;
        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
        params: z.ZodOptional<z.ZodObject<{
            k1: z.ZodNumber;
            b: z.ZodNumber;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    projection: z.ZodOptional<z.ZodObject<{
        type: z.ZodLiteral<"retrieval-index">;
        schemaVersion: z.ZodLiteral<1>;
        contentHash: z.ZodString;
        contentHashAlgo: z.ZodEnum<{
            "sha256-semantic-v1": "sha256-semantic-v1";
            "sha256-normalized-v1": "sha256-normalized-v1";
        }>;
        snapshotHash: z.ZodString;
        overlayHash: z.ZodString;
        configurationHash: z.ZodString;
        lexiconVersion: z.ZodNumber;
        graphMetricsVersion: z.ZodString;
        weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
        params: z.ZodObject<{
            k1: z.ZodNumber;
            b: z.ZodNumber;
        }, z.core.$strict>;
        lexical: z.ZodObject<{
            version: z.ZodNumber;
            documentCount: z.ZodNumber;
            fieldNames: z.ZodArray<z.ZodString>;
            averageFieldLength: z.ZodRecord<z.ZodString, z.ZodNumber>;
        }, z.core.$strict>;
        entries: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodEnum<{
                module: "module";
                area: "area";
                package: "package";
                document: "document";
                intent: "intent";
                change: "change";
            }>;
            path: z.ZodString;
            title: z.ZodString;
            summary: z.ZodOptional<z.ZodString>;
            audience: z.ZodOptional<z.ZodEnum<{
                agent: "agent";
                human: "human";
                "human-and-agent": "human-and-agent";
            }>>;
            aliases: z.ZodArray<z.ZodString>;
            symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tags: z.ZodArray<z.ZodString>;
            fields: z.ZodObject<{
                title: z.ZodString;
                headings: z.ZodString;
                path: z.ZodString;
                symbols: z.ZodString;
                summary: z.ZodString;
                body: z.ZodString;
                aliases: z.ZodString;
            }, z.core.$strict>;
            graph: z.ZodObject<{
                pagerank: z.ZodNumber;
                inboundLinks: z.ZodNumber;
                coveredBy: z.ZodArray<z.ZodString>;
                mentionedBy: z.ZodArray<z.ZodString>;
                areaId: z.ZodOptional<z.ZodString>;
                packageId: z.ZodOptional<z.ZodString>;
                inbound: z.ZodArray<z.ZodObject<{
                    kind: z.ZodString;
                    id: z.ZodString;
                    confidence: z.ZodEnum<{
                        proposed: "proposed";
                        observed: "observed";
                        declared: "declared";
                        fuzzy: "fuzzy";
                    }>;
                }, z.core.$strict>>;
                outbound: z.ZodArray<z.ZodObject<{
                    kind: z.ZodString;
                    id: z.ZodString;
                    confidence: z.ZodEnum<{
                        proposed: "proposed";
                        observed: "observed";
                        declared: "declared";
                        fuzzy: "fuzzy";
                    }>;
                }, z.core.$strict>>;
            }, z.core.$strict>;
            contentHash: z.ZodString;
            provenance: z.ZodEnum<{
                proposed: "proposed";
                observed: "observed";
                declared: "declared";
            }>;
            confidence: z.ZodEnum<{
                proposed: "proposed";
                observed: "observed";
                declared: "declared";
                fuzzy: "fuzzy";
            }>;
            ownershipId: z.ZodOptional<z.ZodString>;
            agentSignal: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    publication: z.ZodOptional<z.ZodObject<{
        pendingReferenceFindings: z.ZodObject<{
            override: z.ZodLiteral<"allow-pending-findings">;
            pendingCount: z.ZodOptional<z.ZodNumber>;
            baseRevision: z.ZodOptional<z.ZodString>;
            reason: z.ZodEnum<{
                "no-base": "no-base";
                "base-unreadable": "base-unreadable";
                "base-invalid": "base-invalid";
                "diff-unavailable": "diff-unavailable";
                pending: "pending";
            }>;
        }, z.core.$strict>;
    }, z.core.$strict>>;
}, z.core.$strict>;
type DocBridgeIndexV1 = z.infer<typeof DocBridgeIndexV1Schema>;
type IndexPublication = z.infer<typeof IndexPublicationSchema>;
type KnowledgeEntry = z.infer<typeof KnowledgeEntrySchema>;
type RepositoryInputs = z.infer<typeof RepositoryInputsSchema>;
type RetrievalMetadata = z.infer<typeof RetrievalMetadataSchema>;

declare const MEMORY_CANDIDATE_SCHEMA_VERSION: 1;
declare const MemoryCandidateV1Schema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<1>;
    id: z.ZodString;
    source: z.ZodEnum<{
        manual: "manual";
        cursor: "cursor";
        claude: "claude";
        codex: "codex";
        copilot: "copilot";
        "agent-memory": "agent-memory";
    }>;
    rawPath: z.ZodOptional<z.ZodString>;
    fact: z.ZodString;
    why: z.ZodOptional<z.ZodString>;
    howToApply: z.ZodOptional<z.ZodString>;
    suggestedType: z.ZodEnum<{
        unknown: "unknown";
        project: "project";
        user: "user";
        feedback: "feedback";
        reference: "reference";
    }>;
    confidence: z.ZodNumber;
    references: z.ZodArray<z.ZodString>;
}, z.core.$strict>;
type MemoryCandidateV1 = z.infer<typeof MemoryCandidateV1Schema>;

type MemoryRoute = 'agent' | 'human' | 'playbook' | 'discard';
type MemoryClassification = {
    readonly candidate: MemoryCandidateV1;
    readonly route: MemoryRoute;
    readonly reason: string;
    readonly target?: string;
    readonly entityRelations?: readonly MemoryEntityRelationV1[];
    readonly duplicateOf?: string;
};
type SafetyFinding = {
    readonly candidateId: string;
    readonly kind: 'secret' | 'private-email';
    readonly message: string;
};
type MemoryPromotionDraft = {
    readonly ok: boolean;
    readonly title: string;
    readonly body: string;
    readonly findings: SafetyFinding[];
    readonly classifications: MemoryClassification[];
};
/** Explicit, exact references only; a shared alias/path never chooses an arbitrary entity. */
declare const linkMemoryToEntities: (candidates: readonly MemoryCandidateV1[], section: KnowledgeEntitiesV1) => MemoryEntityRelationV1[];
declare const classifyMemoryCandidates: (candidates: readonly MemoryCandidateV1[], index: DocBridgeIndexV1) => MemoryClassification[];
declare const scanMemorySafety: (classifications: readonly MemoryClassification[]) => SafetyFinding[];
declare const draftMemoryPromotion: (classifications: readonly MemoryClassification[]) => MemoryPromotionDraft;

type GithubPrOptions = {
    readonly dryRun?: boolean;
    readonly force?: boolean;
    readonly branch?: string;
    readonly base?: string;
};
type GithubPrResult = {
    readonly ok: boolean;
    readonly dryRun: boolean;
    readonly draftPath: string;
    readonly branch: string;
    readonly prUrl?: string;
    readonly previewUrl?: string;
    readonly commands: readonly string[];
    readonly message: string;
};
declare const defaultPromotionDraftPath: (root: string) => string;
declare const writePromotionDraft: (root: string, draft: MemoryPromotionDraft, path?: string) => string;
declare const promoteMemoryToGithubPr: (root: string, draft: MemoryPromotionDraft, options?: GithubPrOptions) => GithubPrResult;

export { KnowledgeEntityV1Schema as $, type AgentProposalV1 as A, type FixChange as B, type Coverage as C, type DiscoverySnapshotV1 as D, type Evidence as E, type FixProposalV1 as F, type GithubPrResult as G, FixChangeSchema as H, type IndexPublication as I, FixProposalStatusSchema as J, type KnowledgeEntry as K, FixProposalV1Schema as L, type MemoryCandidateV1 as M, type GithubPrOptions as N, INDEX_SCHEMA_VERSION as O, KNOWLEDGE_CONTENT_HASH_ALGO as P, KNOWLEDGE_ENTITY_SCHEMA_VERSION as Q, type RemediationV1 as R, KNOWLEDGE_SCHEMA_VERSION as S, type KnowledgeArtifactV1 as T, KnowledgeEntitiesV1Schema as U, type KnowledgeEntityEvidenceV1 as V, type WorkflowRunV1 as W, KnowledgeEntityEvidenceV1Schema as X, type KnowledgeEntityLinkV1 as Y, KnowledgeEntityLinkV1Schema as Z, type KnowledgeEntityV1 as _, type DocBridgeIndexV1 as a, KnowledgeEntrySchema as a0, MEMORY_CANDIDATE_SCHEMA_VERSION as a1, MemoryCandidateV1Schema as a2, type MemoryClassification as a3, type MemoryEntityRelationV1 as a4, MemoryEntityRelationV1Schema as a5, type MemoryPromotionDraft as a6, type MemoryRoute as a7, ProjectIdentitySchema as a8, ProposalOriginSchema as a9, type Provenance as aa, ProvenanceSchema as ab, ReconciliationReportV1Schema as ac, type RegionEdit as ad, RegionEditSchema as ae, RelationSchema as af, RemediationV1Schema as ag, type RepositoryInputs as ah, RepositoryInputsSchema as ai, type RetrievalMetadata as aj, RetrievalMetadataSchema as ak, type SafetyFinding as al, WorkflowRunV1Schema as am, type WorkflowState as an, WorkflowStateSchema as ao, WorkflowStepSchema as ap, WorkflowTransitionSchema as aq, classifyMemoryCandidates as ar, defaultPromotionDraftPath as as, draftMemoryPromotion as at, linkMemoryToEntities as au, promoteMemoryToGithubPr as av, scanMemorySafety as aw, writePromotionDraft as ax, type ReconciliationReportV1 as b, type KnowledgeRelation as c, type KnowledgeEntity as d, type CorrelationContextV1 as e, type WorkflowStep as f, REFERENCE_FINDINGS_REASONS as g, type KnowledgeDiagnostic as h, type FindingV1 as i, type DecisionV1 as j, type KnowledgeEntitiesV1 as k, AffectedFileSchema as l, AgentProposalV1Schema as m, CorrelationContextV1Schema as n, CoverageSchema as o, DecisionV1Schema as p, type DiagnosticSeverity as q, DiagnosticSeveritySchema as r, DiscoverySnapshotV1Schema as s, DocBridgeIndexV1Schema as t, EntitySchema as u, EvidenceSchema as v, EvidenceSourceSchema as w, type FindingStatus as x, FindingStatusSchema as y, FindingV1Schema as z };