import { z } from "zod";
import { type ReferenceTreeEntry } from "../parsers/referenceTree.js";
import type { LeaksReport } from "../types.js";
export declare const diffMemgraphsSchema: z.ZodObject<{
    before: z.ZodString;
    after: z.ZodString;
    outputFormat: z.ZodOptional<z.ZodEnum<["markdown", "json", "both", "verify-fix-table"]>>;
}, "strip", z.ZodTypeAny, {
    after: string;
    before: string;
    outputFormat?: "markdown" | "json" | "both" | "verify-fix-table" | undefined;
}, {
    after: string;
    before: string;
    outputFormat?: "markdown" | "json" | "both" | "verify-fix-table" | undefined;
}>;
export type DiffMemgraphsInput = z.infer<typeof diffMemgraphsSchema>;
export interface CycleSignature {
    /** Top-level class of the cycle, used as a stable identity across snapshots. */
    rootClass: string;
    /** First few descendant class names — fingerprints the chain shape. */
    shape: string[];
}
export interface CycleDiffEntry {
    signature: CycleSignature;
    beforeCount: number;
    afterCount: number;
    delta: number;
}
export interface ReferenceTreeDiffEntry {
    className: string;
    before: number;
    after: number;
    delta: number;
    beforeBytes: number;
    afterBytes: number;
    bytesDelta: number;
}
export interface DiffMemgraphsResult {
    ok: boolean;
    before: {
        path: string;
        leakCount: number;
    };
    after: {
        path: string;
        leakCount: number;
    };
    totals: {
        leakCountDelta: number;
        bytesLeakedDelta: number;
        /**
         * Net instance-count delta from the reference-tree (heap-wide) view.
         * Sum of all `referenceTreeChanges` deltas. Useful for "did the heap
         * shrink overall?" without scrolling per-class. New in v1.11.
         */
        referenceTreeInstanceDelta?: number;
        /** Net bytes delta from the reference-tree view. New in v1.11. */
        referenceTreeBytesDelta?: number;
    };
    classCounts: {
        /** Classes whose count went up (potential new leaks). Cycle-based view. */
        increased: Array<{
            className: string;
            before: number;
            after: number;
            delta: number;
        }>;
        /** Classes whose count went down (fixed leaks or just gone). Cycle-based view. */
        decreased: Array<{
            className: string;
            before: number;
            after: number;
            delta: number;
        }>;
    };
    /**
     * Heap-wide class-count changes from the reference-tree pass. Populated
     * even when `leakCount` is 0 in both snapshots (which is exactly when
     * cycle-only `classCounts` returns empty and the user wants this view).
     * Includes framework noise (NSMutableDictionary, CFString, etc.); see
     * `actionableReferenceTreeChanges` for the filtered view. New in v1.11.
     */
    referenceTreeChanges?: {
        increased: ReferenceTreeDiffEntry[];
        decreased: ReferenceTreeDiffEntry[];
    };
    /**
     * `referenceTreeChanges` with framework noise filtered out via
     * `isFrameworkNoise`. Surfaces AV / KVO / app-level classes for the
     * verify-fix loop without scrolling past Foundation collection growth.
     * New in v1.11.
     */
    actionableReferenceTreeChanges?: {
        increased: ReferenceTreeDiffEntry[];
        decreased: ReferenceTreeDiffEntry[];
    };
    cycles: {
        /** ROOT CYCLE signatures present only in `after`. */
        newInAfter: CycleDiffEntry[];
        /** Signatures present only in `before` (cycle disappeared). */
        goneFromBefore: CycleDiffEntry[];
        /** Signatures present in both; count change is what matters. */
        persisted: CycleDiffEntry[];
    };
}
/** Pure: compare two parsed reports and return a structured diff. */
export declare function diffReports(before: LeaksReport, after: LeaksReport, beforePath: string, afterPath: string): DiffMemgraphsResult;
/**
 * Pure: diff two reference-tree entry lists by class name and return
 * increased / decreased buckets. Each entry carries before/after counts,
 * bytes, and delta values. Sorted: increased by delta desc, decreased by
 * delta asc (most-negative first).
 *
 * Returns null when both inputs are empty. The async wrapper uses this
 * absence to suppress the `referenceTreeChanges` field on the result so
 * cycle-only callers see no change vs v1.10. New in v1.11.
 */
export declare function diffReferenceTrees(before: ReferenceTreeEntry[], after: ReferenceTreeEntry[]): {
    increased: ReferenceTreeDiffEntry[];
    decreased: ReferenceTreeDiffEntry[];
} | null;
export declare function diffMemgraphs(input: DiffMemgraphsInput): Promise<DiffMemgraphsResult>;