import { z } from "zod";
export declare const GraphEdgeSchema: z.ZodObject<{
    from: z.ZodString;
    to: z.ZodString;
    kind: z.ZodOptional<z.ZodString>;
    direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
    confidence: z.ZodOptional<z.ZodNumber>;
    reason: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    from: string;
    to: string;
    reason?: string | undefined;
    confidence?: number | undefined;
    kind?: string | undefined;
    direction?: "directed" | "undirected" | undefined;
}, {
    from: string;
    to: string;
    reason?: string | undefined;
    confidence?: number | undefined;
    kind?: string | undefined;
    direction?: "directed" | "undirected" | undefined;
}>;
export type GraphEdge = z.infer<typeof GraphEdgeSchema>;
export declare const RouteEdgeSchema: z.ZodObject<{
    path: z.ZodString;
    handler: z.ZodString;
    method: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    path: string;
    handler: string;
    method?: string | undefined;
}, {
    path: string;
    handler: string;
    method?: string | undefined;
}>;
export type RouteEdge = z.infer<typeof RouteEdgeSchema>;
/**
 * Per-node structural measure (one of complexity / duplication). `value` is the
 * raw metric, `measure` names the concrete algorithm used (so consumers never
 * guess units), and `reach` records the scope of source the measure actually
 * covered — currently only `'js-ts-effective'` (computed over JS/TS source).
 */
export declare const NodeMetricSchema: z.ZodObject<{
    value: z.ZodNumber;
    measure: z.ZodString;
    reach: z.ZodLiteral<"js-ts-effective">;
}, "strict", z.ZodTypeAny, {
    value: number;
    measure: string;
    reach: "js-ts-effective";
}, {
    value: number;
    measure: string;
    reach: "js-ts-effective";
}>;
export type NodeMetric = z.infer<typeof NodeMetricSchema>;
/**
 * Optional per-node (repo-path keyed) structural metrics computed at graph-build
 * time, where the file source is available. Absent for non-js/ts files (never
 * zero-filled). Each metric is independently optional. Declared as an explicit
 * optional Zod field (not a catchall) so a `.strict()` bundle WITHOUT
 * `node_metrics` still parses, while an unknown sibling key is rejected.
 */
export declare const NodeMetricsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
    complexity: z.ZodOptional<z.ZodObject<{
        value: z.ZodNumber;
        measure: z.ZodString;
        reach: z.ZodLiteral<"js-ts-effective">;
    }, "strict", z.ZodTypeAny, {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    }, {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    }>>;
    duplication: z.ZodOptional<z.ZodObject<{
        value: z.ZodNumber;
        measure: z.ZodString;
        reach: z.ZodLiteral<"js-ts-effective">;
    }, "strict", z.ZodTypeAny, {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    }, {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    }>>;
}, "strict", z.ZodTypeAny, {
    complexity?: {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    } | undefined;
    duplication?: {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    } | undefined;
}, {
    complexity?: {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    } | undefined;
    duplication?: {
        value: number;
        measure: string;
        reach: "js-ts-effective";
    } | undefined;
}>>;
export type NodeMetrics = z.infer<typeof NodeMetricsSchema>;
export declare const GraphBundleSchema: z.ZodObject<{
    graphs: z.ZodObject<{
        imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            handler: z.ZodString;
            method: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            path: string;
            handler: string;
            method?: string | undefined;
        }, {
            path: string;
            handler: string;
            method?: string | undefined;
        }>, "many">>;
    }, "strip", z.ZodUnknown, z.objectOutputType<{
        imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            handler: z.ZodString;
            method: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            path: string;
            handler: string;
            method?: string | undefined;
        }, {
            path: string;
            handler: string;
            method?: string | undefined;
        }>, "many">>;
    }, z.ZodUnknown, "strip">, z.objectInputType<{
        imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            kind: z.ZodOptional<z.ZodString>;
            direction: z.ZodOptional<z.ZodEnum<["directed", "undirected"]>>;
            confidence: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }, {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }>, "many">>;
        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            handler: z.ZodString;
            method: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            path: string;
            handler: string;
            method?: string | undefined;
        }, {
            path: string;
            handler: string;
            method?: string | undefined;
        }>, "many">>;
    }, z.ZodUnknown, "strip">>;
    /**
     * Provenance for the optional graph-enrichment pass: the ids of the language
     * analyzers whose edges were merged into this bundle (empty/absent when only
     * the deterministic regex floor was used). See Phase 5 analyzer seam.
     */
    analyzers_used: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    /**
     * Optional per-node structural metrics (complexity / duplication) computed at
     * graph-build time over js/ts source. Explicit optional field so legacy
     * bundles without it still parse under `.strict()`.
     */
    node_metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        complexity: z.ZodOptional<z.ZodObject<{
            value: z.ZodNumber;
            measure: z.ZodString;
            reach: z.ZodLiteral<"js-ts-effective">;
        }, "strict", z.ZodTypeAny, {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        }, {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        }>>;
        duplication: z.ZodOptional<z.ZodObject<{
            value: z.ZodNumber;
            measure: z.ZodString;
            reach: z.ZodLiteral<"js-ts-effective">;
        }, "strict", z.ZodTypeAny, {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        }, {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        }>>;
    }, "strict", z.ZodTypeAny, {
        complexity?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
        duplication?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
    }, {
        complexity?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
        duplication?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
    }>>>;
}, "strict", z.ZodTypeAny, {
    graphs: {
        imports?: {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }[] | undefined;
        calls?: {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }[] | undefined;
        references?: {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }[] | undefined;
        routes?: {
            path: string;
            handler: string;
            method?: string | undefined;
        }[] | undefined;
    } & {
        [k: string]: unknown;
    };
    analyzers_used?: string[] | undefined;
    node_metrics?: Record<string, {
        complexity?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
        duplication?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
    }> | undefined;
}, {
    graphs: {
        imports?: {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }[] | undefined;
        calls?: {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }[] | undefined;
        references?: {
            from: string;
            to: string;
            reason?: string | undefined;
            confidence?: number | undefined;
            kind?: string | undefined;
            direction?: "directed" | "undirected" | undefined;
        }[] | undefined;
        routes?: {
            path: string;
            handler: string;
            method?: string | undefined;
        }[] | undefined;
    } & {
        [k: string]: unknown;
    };
    analyzers_used?: string[] | undefined;
    node_metrics?: Record<string, {
        complexity?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
        duplication?: {
            value: number;
            measure: string;
            reach: "js-ts-effective";
        } | undefined;
    }> | undefined;
}>;
export type GraphBundle = z.infer<typeof GraphBundleSchema>;
//# sourceMappingURL=graph.d.ts.map