import { z } from 'zod';

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 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<{
        content: "content";
        git: "git";
    }>;
    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<{
        content: "content";
        git: "git";
    }>;
    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<{
        content: "content";
        git: "git";
    }>;
    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<{
        content: "content";
        git: "git";
    }>;
    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<{
        content: "content";
        git: "git";
    }>;
    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;

export { type AgentProposalV1 as A, KNOWLEDGE_SCHEMA_VERSION as B, type Coverage as C, type DiscoverySnapshotV1 as D, type Evidence as E, type FixProposalV1 as F, type KnowledgeArtifactV1 as G, KnowledgeEntrySchema as H, type IndexPublication as I, ProposalOriginSchema as J, type KnowledgeDiagnostic as K, type Provenance as L, ProvenanceSchema as M, ReconciliationReportV1Schema as N, RelationSchema as O, ProjectIdentitySchema as P, type RepositoryInputs as Q, REFERENCE_FINDINGS_REASONS as R, RepositoryInputsSchema as S, type RetrievalMetadata as T, RetrievalMetadataSchema as U, WorkflowRunV1Schema as V, type WorkflowRunV1 as W, type WorkflowState as X, WorkflowStateSchema as Y, WorkflowStepSchema as Z, WorkflowTransitionSchema as _, type DocBridgeIndexV1 as a, type ReconciliationReportV1 as b, type KnowledgeEntry as c, type KnowledgeRelation as d, type KnowledgeEntity as e, type CorrelationContextV1 as f, type WorkflowStep as g, AffectedFileSchema as h, AgentProposalV1Schema as i, CorrelationContextV1Schema as j, CoverageSchema as k, type DiagnosticSeverity as l, DiagnosticSeveritySchema as m, DiscoverySnapshotV1Schema as n, DocBridgeIndexV1Schema as o, EntitySchema as p, EvidenceSchema as q, EvidenceSourceSchema as r, type FindingStatus as s, FindingStatusSchema as t, type FixChange as u, FixChangeSchema as v, FixProposalStatusSchema as w, FixProposalV1Schema as x, INDEX_SCHEMA_VERSION as y, KNOWLEDGE_CONTENT_HASH_ALGO as z };