import { z } from 'zod';
import type { OccEntityIntelligenceSession } from '../code/entity/session.js';
import type { EntityBounds } from '../code/entity/types.js';
/**
 * The thirteen `occ_*` MCP tools.
 *
 * Inputs are OCC's own Zod schemas, so an MCP client is validated by exactly
 * the rules the CLI applies — the published JSON Schema is generated from them
 * and cannot drift. Outputs are declared as *loose* envelopes: the status
 * discriminant a client must switch on is pinned, while the payload passes
 * through unvalidated. That is deliberate. The SDK rejects a call whose
 * `structuredContent` fails its declared `outputSchema`, so a strict mirror of
 * the result interfaces would turn any additive OCC change into a hard error
 * for every already-shipped client. The diff receipt adds contradiction-only
 * cross-field checks, never closed-world equality. The authoritative
 * field-by-field contract is the exported TypeScript type named in each tool's
 * description.
 */
/** Tool names, exported so tests and docs enumerate the same list the server registers. */
export declare const OCC_MCP_TOOL_NAMES: readonly ["occ_doc", "occ_pattern", "occ_entities", "occ_hotspots", "occ_cochange", "occ_diff", "occ_impact", "occ_blame", "occ_log", "occ_context", "occ_status", "occ_source", "occ_anchor"];
export type OccMcpToolName = (typeof OCC_MCP_TOOL_NAMES)[number];
export declare const MCP_RESPONSE_FORMATS: readonly ["concise", "detailed"];
export type McpResponseFormat = (typeof MCP_RESPONSE_FORMATS)[number];
export interface OccMcpToolExample {
    label: 'minimal' | 'partial' | 'full';
    arguments: Readonly<Record<string, unknown>>;
}
/**
 * Executable argument examples shared by the advertised descriptions and the
 * schema contract test. Keeping the objects here makes a stale example fail
 * against the same Zod input shape that rejects a real MCP request.
 */
export declare const OCC_MCP_TOOL_EXAMPLES: {
    readonly occ_doc: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly name: "buildRepoMap";
        };
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly name: "getSession";
            readonly relativePath: "src/code/store.ts";
            readonly kind: "function";
            readonly containerName: "CodeIndexStore";
            readonly tokenizer: "o200k_base";
            readonly response_format: "concise";
        };
    }];
    readonly occ_pattern: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly language: "typescript";
            readonly pattern: "JSON.parse($A)";
        };
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly language: "typescript";
            readonly pattern: "JSON.parse($A)";
            readonly relativePath: "src";
            readonly limit: 20;
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly language: "typescript";
            readonly rule: {
                readonly matches: "json-parse";
            };
            readonly utils: {
                readonly 'json-parse': {
                    readonly pattern: "JSON.parse($A)";
                };
            };
            readonly relativePath: "src";
            readonly limit: 50;
            readonly response_format: "concise";
        };
    }];
    readonly occ_entities: readonly [{
        readonly label: "minimal";
        readonly arguments: {};
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly query: "Cache";
            readonly relativePath: "src";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly query: "Cache";
            readonly kind: "class";
            readonly relativePath: "src";
            readonly limit: 25;
            readonly includeTests: false;
            readonly response_format: "concise";
        };
    }];
    readonly occ_hotspots: readonly [{
        readonly label: "minimal";
        readonly arguments: {};
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly relativePath: "src";
            readonly limit: 10;
            readonly since: "2026-01-01";
            readonly pageRank: true;
            readonly response_format: "concise";
        };
    }];
    readonly occ_cochange: readonly [{
        readonly label: "minimal";
        readonly arguments: {};
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
            readonly kind: "function";
            readonly limit: 10;
            readonly minCount: 2;
            readonly minConfidence: 0.5;
            readonly maxCommitEntities: 250;
            readonly response_format: "concise";
        };
    }];
    readonly occ_diff: readonly [{
        readonly label: "minimal";
        readonly arguments: {};
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly base: "main";
            readonly obligations: true;
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly base: "main";
            readonly head: "HEAD";
            readonly rangeMode: "exact";
            readonly relativePath: "src/code/map.ts";
            readonly maxEntities: 500;
            readonly formats: false;
            readonly obligations: true;
            readonly response_format: "concise";
        };
    }];
    readonly occ_impact: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly name: "buildRepoMap";
        };
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly scope: "tests";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
            readonly kind: "function";
            readonly scope: "all";
            readonly depth: 3;
            readonly maxEntities: 250;
            readonly inline_context: 2;
            readonly response_format: "concise";
        };
    }];
    readonly occ_blame: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly relativePath: "src/code/map.ts";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly relativePath: "src/code/map.ts";
            readonly ref: "HEAD~1";
            readonly walkBack: false;
            readonly response_format: "concise";
        };
    }];
    readonly occ_log: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly name: "buildRepoMap";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
            readonly kind: "function";
            readonly limit: 10;
            readonly ref: "HEAD~1";
            readonly walkBack: false;
            readonly response_format: "concise";
        };
    }];
    readonly occ_context: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly name: "buildRepoMap";
        };
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly include: readonly ["deps"];
            readonly tokenBudget: 4000;
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
            readonly kind: "function";
            readonly tokenBudget: 8000;
            readonly hops: 2;
            readonly include: readonly ["deps", "dependents"];
            readonly tokenizer: "o200k_base";
            readonly inline_context: 2;
            readonly response_format: "concise";
        };
    }];
    readonly occ_status: readonly [{
        readonly label: "minimal";
        readonly arguments: {};
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly workingTree: false;
            readonly response_format: "concise";
        };
    }];
    readonly occ_source: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly name: "buildRepoMap";
        };
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
            readonly tokenizer: "o200k_base";
            readonly response_format: "concise";
        };
    }];
    readonly occ_anchor: readonly [{
        readonly label: "minimal";
        readonly arguments: {
            readonly name: "buildRepoMap";
        };
    }, {
        readonly label: "partial";
        readonly arguments: {
            readonly name: "buildRepoMap";
            readonly relativePath: "src/code/map.ts";
        };
    }, {
        readonly label: "full";
        readonly arguments: {
            readonly lineageId: "ent1:0123456789abcdef0123456789abcdef";
            readonly response_format: "concise";
        };
    }];
};
/** Append schema-checked examples to one tool's human-readable MCP contract. */
export declare function withOccMcpToolExamples(name: OccMcpToolName, description: string): string;
export declare const entitiesInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    query: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        file: "file";
        enum: "enum";
        type: "type";
        module: "module";
        class: "class";
        interface: "interface";
        variable: "variable";
        parameter: "parameter";
        method: "method";
        other: "other";
    }>, z.ZodEnum<{
        object: "object";
        array: "array";
        "array-item": "array-item";
        property: "property";
        section: "section";
        table: "table";
        "array-table": "array-table";
        heading: "heading";
        row: "row";
        document: "document";
    }>, z.ZodEnum<{
        test: "test";
        test_suite: "test_suite";
    }>]>>;
    relativePath: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
    includeTests: z.ZodOptional<z.ZodBoolean>;
};
export declare const docInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodOptional<z.ZodString>;
    nodeId: z.ZodOptional<z.ZodString>;
    relativePath: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodEnum<{
        function: "function";
        enum: "enum";
        class: "class";
        interface: "interface";
        "type-alias": "type-alias";
        variable: "variable";
    }>>;
    containerName: z.ZodOptional<z.ZodString>;
    tokenizer: z.ZodOptional<z.ZodEnum<{
        heuristic: "heuristic";
        o200k_base: "o200k_base";
        cl100k_base: "cl100k_base";
    }>>;
};
export declare const sourceInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodOptional<z.ZodString>;
    nodeId: z.ZodOptional<z.ZodString>;
    relativePath: z.ZodOptional<z.ZodString>;
    tokenizer: z.ZodOptional<z.ZodEnum<{
        heuristic: "heuristic";
        o200k_base: "o200k_base";
        cl100k_base: "cl100k_base";
    }>>;
};
export declare const anchorInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodOptional<z.ZodString>;
    lineageId: z.ZodOptional<z.ZodString>;
    nodeId: z.ZodOptional<z.ZodString>;
    relativePath: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        file: "file";
        enum: "enum";
        type: "type";
        module: "module";
        class: "class";
        interface: "interface";
        variable: "variable";
        parameter: "parameter";
        method: "method";
        other: "other";
    }>, z.ZodEnum<{
        object: "object";
        array: "array";
        "array-item": "array-item";
        property: "property";
        section: "section";
        table: "table";
        "array-table": "array-table";
        heading: "heading";
        row: "row";
        document: "document";
    }>, z.ZodEnum<{
        test: "test";
        test_suite: "test_suite";
    }>]>>;
    containerName: z.ZodOptional<z.ZodString>;
};
export declare const patternInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    language: z.ZodString;
    pattern: z.ZodOptional<z.ZodString>;
    rule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    utils: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    relativePath: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
};
export declare const hotspotsInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    relativePath: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
    since: z.ZodOptional<z.ZodString>;
    pageRank: z.ZodOptional<z.ZodBoolean>;
};
export declare const cochangeInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodOptional<z.ZodString>;
    relativePath: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        file: "file";
        enum: "enum";
        type: "type";
        module: "module";
        class: "class";
        interface: "interface";
        variable: "variable";
        parameter: "parameter";
        method: "method";
        other: "other";
    }>, z.ZodEnum<{
        object: "object";
        array: "array";
        "array-item": "array-item";
        property: "property";
        section: "section";
        table: "table";
        "array-table": "array-table";
        heading: "heading";
        row: "row";
        document: "document";
    }>, z.ZodEnum<{
        test: "test";
        test_suite: "test_suite";
    }>]>>;
    limit: z.ZodOptional<z.ZodNumber>;
    minCount: z.ZodOptional<z.ZodNumber>;
    minConfidence: z.ZodOptional<z.ZodNumber>;
    maxCommitEntities: z.ZodOptional<z.ZodNumber>;
};
export declare const diffInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    base: z.ZodOptional<z.ZodString>;
    head: z.ZodOptional<z.ZodString>;
    staged: z.ZodOptional<z.ZodBoolean>;
    relativePath: z.ZodOptional<z.ZodString>;
    maxEntities: z.ZodOptional<z.ZodNumber>;
    rangeMode: z.ZodOptional<z.ZodEnum<{
        exact: "exact";
        "merge-base": "merge-base";
    }>>;
    formats: z.ZodOptional<z.ZodBoolean>;
    obligations: z.ZodOptional<z.ZodBoolean>;
};
export declare const impactInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodString;
    relativePath: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        file: "file";
        enum: "enum";
        type: "type";
        module: "module";
        class: "class";
        interface: "interface";
        variable: "variable";
        parameter: "parameter";
        method: "method";
        other: "other";
    }>, z.ZodEnum<{
        object: "object";
        array: "array";
        "array-item": "array-item";
        property: "property";
        section: "section";
        table: "table";
        "array-table": "array-table";
        heading: "heading";
        row: "row";
        document: "document";
    }>, z.ZodEnum<{
        test: "test";
        test_suite: "test_suite";
    }>]>>;
    scope: z.ZodOptional<z.ZodEnum<{
        all: "all";
        tests: "tests";
        deps: "deps";
        dependents: "dependents";
    }>>;
    depth: z.ZodOptional<z.ZodNumber>;
    maxEntities: z.ZodOptional<z.ZodNumber>;
    inline_context: z.ZodOptional<z.ZodNumber>;
};
export declare const blameInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    relativePath: z.ZodString;
    ref: z.ZodOptional<z.ZodString>;
    walkBack: z.ZodOptional<z.ZodBoolean>;
};
export declare const logInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodString;
    relativePath: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        file: "file";
        enum: "enum";
        type: "type";
        module: "module";
        class: "class";
        interface: "interface";
        variable: "variable";
        parameter: "parameter";
        method: "method";
        other: "other";
    }>, z.ZodEnum<{
        object: "object";
        array: "array";
        "array-item": "array-item";
        property: "property";
        section: "section";
        table: "table";
        "array-table": "array-table";
        heading: "heading";
        row: "row";
        document: "document";
    }>, z.ZodEnum<{
        test: "test";
        test_suite: "test_suite";
    }>]>>;
    limit: z.ZodOptional<z.ZodNumber>;
    ref: z.ZodOptional<z.ZodString>;
    walkBack: z.ZodOptional<z.ZodBoolean>;
};
export declare const contextInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    name: z.ZodString;
    relativePath: z.ZodOptional<z.ZodString>;
    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        file: "file";
        enum: "enum";
        type: "type";
        module: "module";
        class: "class";
        interface: "interface";
        variable: "variable";
        parameter: "parameter";
        method: "method";
        other: "other";
    }>, z.ZodEnum<{
        object: "object";
        array: "array";
        "array-item": "array-item";
        property: "property";
        section: "section";
        table: "table";
        "array-table": "array-table";
        heading: "heading";
        row: "row";
        document: "document";
    }>, z.ZodEnum<{
        test: "test";
        test_suite: "test_suite";
    }>]>>;
    tokenBudget: z.ZodOptional<z.ZodNumber>;
    hops: z.ZodOptional<z.ZodNumber>;
    include: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        deps: "deps";
        dependents: "dependents";
    }>>>;
    tokenizer: z.ZodOptional<z.ZodEnum<{
        heuristic: "heuristic";
        o200k_base: "o200k_base";
        cl100k_base: "cl100k_base";
    }>>;
    inline_context: z.ZodOptional<z.ZodNumber>;
};
export declare const statusInputShape: {
    response_format: z.ZodOptional<z.ZodEnum<{
        concise: "concise";
        detailed: "detailed";
    }>>;
    workingTree: z.ZodOptional<z.ZodBoolean>;
};
/** Zod objects used by the example contract test and real handler inference. */
export declare const OCC_MCP_INPUT_SCHEMAS: {
    occ_doc: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        relativePath: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodEnum<{
            function: "function";
            enum: "enum";
            class: "class";
            interface: "interface";
            "type-alias": "type-alias";
            variable: "variable";
        }>>;
        containerName: z.ZodOptional<z.ZodString>;
        tokenizer: z.ZodOptional<z.ZodEnum<{
            heuristic: "heuristic";
            o200k_base: "o200k_base";
            cl100k_base: "cl100k_base";
        }>>;
    }, z.core.$strip>;
    occ_pattern: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        language: z.ZodString;
        pattern: z.ZodOptional<z.ZodString>;
        rule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        utils: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        relativePath: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    occ_entities: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        query: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
            function: "function";
            file: "file";
            enum: "enum";
            type: "type";
            module: "module";
            class: "class";
            interface: "interface";
            variable: "variable";
            parameter: "parameter";
            method: "method";
            other: "other";
        }>, z.ZodEnum<{
            object: "object";
            array: "array";
            "array-item": "array-item";
            property: "property";
            section: "section";
            table: "table";
            "array-table": "array-table";
            heading: "heading";
            row: "row";
            document: "document";
        }>, z.ZodEnum<{
            test: "test";
            test_suite: "test_suite";
        }>]>>;
        relativePath: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
        includeTests: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    occ_hotspots: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        relativePath: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodNumber>;
        since: z.ZodOptional<z.ZodString>;
        pageRank: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    occ_cochange: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodOptional<z.ZodString>;
        relativePath: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
            function: "function";
            file: "file";
            enum: "enum";
            type: "type";
            module: "module";
            class: "class";
            interface: "interface";
            variable: "variable";
            parameter: "parameter";
            method: "method";
            other: "other";
        }>, z.ZodEnum<{
            object: "object";
            array: "array";
            "array-item": "array-item";
            property: "property";
            section: "section";
            table: "table";
            "array-table": "array-table";
            heading: "heading";
            row: "row";
            document: "document";
        }>, z.ZodEnum<{
            test: "test";
            test_suite: "test_suite";
        }>]>>;
        limit: z.ZodOptional<z.ZodNumber>;
        minCount: z.ZodOptional<z.ZodNumber>;
        minConfidence: z.ZodOptional<z.ZodNumber>;
        maxCommitEntities: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    occ_diff: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        base: z.ZodOptional<z.ZodString>;
        head: z.ZodOptional<z.ZodString>;
        staged: z.ZodOptional<z.ZodBoolean>;
        relativePath: z.ZodOptional<z.ZodString>;
        maxEntities: z.ZodOptional<z.ZodNumber>;
        rangeMode: z.ZodOptional<z.ZodEnum<{
            exact: "exact";
            "merge-base": "merge-base";
        }>>;
        formats: z.ZodOptional<z.ZodBoolean>;
        obligations: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    occ_impact: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodString;
        relativePath: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
            function: "function";
            file: "file";
            enum: "enum";
            type: "type";
            module: "module";
            class: "class";
            interface: "interface";
            variable: "variable";
            parameter: "parameter";
            method: "method";
            other: "other";
        }>, z.ZodEnum<{
            object: "object";
            array: "array";
            "array-item": "array-item";
            property: "property";
            section: "section";
            table: "table";
            "array-table": "array-table";
            heading: "heading";
            row: "row";
            document: "document";
        }>, z.ZodEnum<{
            test: "test";
            test_suite: "test_suite";
        }>]>>;
        scope: z.ZodOptional<z.ZodEnum<{
            all: "all";
            tests: "tests";
            deps: "deps";
            dependents: "dependents";
        }>>;
        depth: z.ZodOptional<z.ZodNumber>;
        maxEntities: z.ZodOptional<z.ZodNumber>;
        inline_context: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    occ_blame: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        relativePath: z.ZodString;
        ref: z.ZodOptional<z.ZodString>;
        walkBack: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    occ_log: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodString;
        relativePath: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
            function: "function";
            file: "file";
            enum: "enum";
            type: "type";
            module: "module";
            class: "class";
            interface: "interface";
            variable: "variable";
            parameter: "parameter";
            method: "method";
            other: "other";
        }>, z.ZodEnum<{
            object: "object";
            array: "array";
            "array-item": "array-item";
            property: "property";
            section: "section";
            table: "table";
            "array-table": "array-table";
            heading: "heading";
            row: "row";
            document: "document";
        }>, z.ZodEnum<{
            test: "test";
            test_suite: "test_suite";
        }>]>>;
        limit: z.ZodOptional<z.ZodNumber>;
        ref: z.ZodOptional<z.ZodString>;
        walkBack: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    occ_context: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodString;
        relativePath: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
            function: "function";
            file: "file";
            enum: "enum";
            type: "type";
            module: "module";
            class: "class";
            interface: "interface";
            variable: "variable";
            parameter: "parameter";
            method: "method";
            other: "other";
        }>, z.ZodEnum<{
            object: "object";
            array: "array";
            "array-item": "array-item";
            property: "property";
            section: "section";
            table: "table";
            "array-table": "array-table";
            heading: "heading";
            row: "row";
            document: "document";
        }>, z.ZodEnum<{
            test: "test";
            test_suite: "test_suite";
        }>]>>;
        tokenBudget: z.ZodOptional<z.ZodNumber>;
        hops: z.ZodOptional<z.ZodNumber>;
        include: z.ZodOptional<z.ZodArray<z.ZodEnum<{
            deps: "deps";
            dependents: "dependents";
        }>>>;
        tokenizer: z.ZodOptional<z.ZodEnum<{
            heuristic: "heuristic";
            o200k_base: "o200k_base";
            cl100k_base: "cl100k_base";
        }>>;
        inline_context: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    occ_status: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        workingTree: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    occ_source: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        relativePath: z.ZodOptional<z.ZodString>;
        tokenizer: z.ZodOptional<z.ZodEnum<{
            heuristic: "heuristic";
            o200k_base: "o200k_base";
            cl100k_base: "cl100k_base";
        }>>;
    }, z.core.$strip>;
    occ_anchor: z.ZodObject<{
        response_format: z.ZodOptional<z.ZodEnum<{
            concise: "concise";
            detailed: "detailed";
        }>>;
        name: z.ZodOptional<z.ZodString>;
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        relativePath: z.ZodOptional<z.ZodString>;
        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
            function: "function";
            file: "file";
            enum: "enum";
            type: "type";
            module: "module";
            class: "class";
            interface: "interface";
            variable: "variable";
            parameter: "parameter";
            method: "method";
            other: "other";
        }>, z.ZodEnum<{
            object: "object";
            array: "array";
            "array-item": "array-item";
            property: "property";
            section: "section";
            table: "table";
            "array-table": "array-table";
            heading: "heading";
            row: "row";
            document: "document";
        }>, z.ZodEnum<{
            test: "test";
            test_suite: "test_suite";
        }>]>>;
        containerName: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
};
export declare const entitiesOutputSchema: z.ZodObject<{
    entities: z.ZodArray<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>;
    count: z.ZodNumber;
    totalMatches: z.ZodNumber;
    limit: z.ZodNumber;
    truncated: z.ZodBoolean;
    honesty: z.ZodObject<{
        ambiguityCount: z.ZodNumber;
        evidenceGaps: z.ZodObject<{
            count: z.ZodNumber;
            reasons: z.ZodArray<z.ZodObject<{
                code: z.ZodString;
                message: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>;
    }, z.core.$loose>;
}, z.core.$loose>;
export declare const patternOutputSchema: z.ZodObject<{
    status: z.ZodLiteral<"resolved">;
    language: z.ZodString;
    engine: z.ZodOptional<z.ZodObject<{
        name: z.ZodString;
        version: z.ZodString;
    }, z.core.$loose>>;
    totalMatches: z.ZodNumber;
    truncated: z.ZodBoolean;
    matches: z.ZodArray<z.ZodObject<{
        relativePath: z.ZodString;
        kind: z.ZodString;
        startLine: z.ZodNumber;
        text: z.ZodString;
    }, z.core.$loose>>;
}, z.core.$loose>;
export declare const docOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
        unsupported: "unsupported";
    }>;
    signature: z.ZodOptional<z.ZodString>;
    params: z.ZodOptional<z.ZodArray<z.ZodString>>;
    docComment: z.ZodOptional<z.ZodString>;
    bodyTokens: z.ZodOptional<z.ZodNumber>;
    tokenizer: z.ZodOptional<z.ZodString>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const anchorOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
    }>;
    anchor: z.ZodOptional<z.ZodObject<{
        lineageId: z.ZodString;
        symbolKey: z.ZodObject<{
            relativePath: z.ZodString;
            name: z.ZodString;
        }, z.core.$loose>;
        baseCommit: z.ZodOptional<z.ZodString>;
        expected: z.ZodObject<{
            bodyHash: z.ZodString;
        }, z.core.$loose>;
    }, z.core.$loose>>;
    freshness: z.ZodOptional<z.ZodObject<{
        fresh: z.ZodBoolean;
    }, z.core.$loose>>;
    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        relativePath: z.ZodString;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const sourceOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
    }>;
    source: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
    relativePath: z.ZodOptional<z.ZodString>;
    span: z.ZodOptional<z.ZodObject<{
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        exact: z.ZodBoolean;
    }, z.core.$loose>>;
    tokens: z.ZodOptional<z.ZodNumber>;
    tokenizer: z.ZodOptional<z.ZodString>;
    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        nodeId: z.ZodString;
        name: z.ZodString;
        path: z.ZodString;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
    honesty: z.ZodOptional<z.ZodObject<{
        freshness: z.ZodObject<{
            fresh: z.ZodBoolean;
            reasons: z.ZodArray<z.ZodString>;
            workingTreeMeasured: z.ZodBoolean;
        }, z.core.$loose>;
        truncation: z.ZodObject<{
            truncated: z.ZodBoolean;
            reasons: z.ZodArray<z.ZodObject<{
                code: z.ZodString;
                message: z.ZodString;
            }, z.core.$loose>>;
            omitted: z.ZodNumber;
        }, z.core.$loose>;
        coverage: z.ZodObject<{
            indexNodesConsidered: z.ZodNumber;
            candidatesMatched: z.ZodNumber;
            sourceRead: z.ZodBoolean;
        }, z.core.$loose>;
        ambiguityCount: z.ZodNumber;
        evidenceGaps: z.ZodObject<{
            count: z.ZodNumber;
            reasons: z.ZodArray<z.ZodObject<{
                code: z.ZodString;
                message: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>;
    }, z.core.$loose>>;
}, z.core.$loose>;
export declare const hotspotsOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
    }>;
    rows: z.ZodOptional<z.ZodArray<z.ZodObject<{
        entity: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        logicChangeCount: z.ZodNumber;
        cosmeticChangeCount: z.ZodNumber;
        lastLogicChange: z.ZodString;
        ageDays: z.ZodNumber;
        score: z.ZodNumber;
    }, z.core.$loose>>>;
    honesty: z.ZodOptional<z.ZodObject<{
        ambiguityCount: z.ZodNumber;
    }, z.core.$loose>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const cochangeOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
    }>;
    entity: z.ZodOptional<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>;
    pairs: z.ZodOptional<z.ZodArray<z.ZodObject<{
        a: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        b: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        cochangeCount: z.ZodNumber;
        aChangeCount: z.ZodNumber;
        confidence: z.ZodNumber;
        lastCoChange: z.ZodString;
    }, z.core.$loose>>>;
    windowCommits: z.ZodOptional<z.ZodNumber>;
    honesty: z.ZodOptional<z.ZodObject<{
        ambiguityCount: z.ZodNumber;
    }, z.core.$loose>>;
    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const diffOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
    }>;
    changedFiles: z.ZodArray<z.ZodString>;
    changes: z.ZodArray<z.ZodObject<{
        changeType: z.ZodString;
        confidence: z.ZodOptional<z.ZodNumber>;
    }, z.core.$loose>>;
    truncated: z.ZodBoolean;
    omitted: z.ZodNumber;
    diagnostics: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
    }, z.core.$loose>>;
    semantic: z.ZodObject<{
        scope: z.ZodOptional<z.ZodLiteral<"entity-records">>;
        verdict: z.ZodEnum<{
            unknown: "unknown";
            "logic-change": "logic-change";
            "semantic-no-op": "semantic-no-op";
        }>;
        coverage: z.ZodEnum<{
            partial: "partial";
            unavailable: "unavailable";
            complete: "complete";
        }>;
        counts: z.ZodObject<{
            logic: z.ZodNumber;
            cosmetic: z.ZodNumber;
            unknown: z.ZodNumber;
        }, z.core.$loose>;
    }, z.core.$loose>;
    wholeDiffSemantic: z.ZodOptional<z.ZodObject<{
        scope: z.ZodLiteral<"whole-diff">;
        proof: z.ZodEnum<{
            "whole-file-cst-v3": "whole-file-cst-v3";
            "whole-file-cst-v4": "whole-file-cst-v4";
        }>;
        grammarManifestDigest: z.ZodOptional<z.ZodString>;
        triviaPolicyDigest: z.ZodOptional<z.ZodString>;
        verdict: z.ZodEnum<{
            unknown: "unknown";
            "logic-change": "logic-change";
            "semantic-no-op": "semantic-no-op";
            "cosmetic-change": "cosmetic-change";
        }>;
        coverage: z.ZodEnum<{
            partial: "partial";
            unavailable: "unavailable";
            complete: "complete";
        }>;
        counts: z.ZodObject<{
            logic: z.ZodNumber;
            noOp: z.ZodNumber;
            unknown: z.ZodNumber;
            cosmetic: z.ZodOptional<z.ZodNumber>;
            whitespaceOnly: z.ZodOptional<z.ZodNumber>;
            commentOnly: z.ZodOptional<z.ZodNumber>;
        }, z.core.$loose>;
        files: z.ZodArray<z.ZodObject<{
            relativePath: z.ZodString;
            previousPath: z.ZodOptional<z.ZodString>;
            status: z.ZodEnum<{
                unknown: "unknown";
                added: "added";
                modified: "modified";
                deleted: "deleted";
                renamed: "renamed";
                copied: "copied";
                "type-changed": "type-changed";
                unmerged: "unmerged";
            }>;
            verdict: z.ZodString;
            coverage: z.ZodEnum<{
                partial: "partial";
                unavailable: "unavailable";
                complete: "complete";
            }>;
            basis: z.ZodString;
            grammar: z.ZodOptional<z.ZodString>;
            grammarDigest: z.ZodOptional<z.ZodString>;
            grammarManifestDigest: z.ZodOptional<z.ZodString>;
            triviaPolicyDigest: z.ZodOptional<z.ZodString>;
            oldMode: z.ZodOptional<z.ZodString>;
            newMode: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>>;
        evidenceGaps: z.ZodObject<{
            unclassifiedFiles: z.ZodArray<z.ZodObject<{
                relativePath: z.ZodString;
                basis: z.ZodString;
            }, z.core.$loose>>;
            diagnostics: z.ZodArray<z.ZodObject<{
                code: z.ZodString;
                message: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>;
        gitScope: z.ZodOptional<z.ZodObject<{
            range: z.ZodObject<{
                base: z.ZodOptional<z.ZodString>;
                head: z.ZodOptional<z.ZodString>;
                kind: z.ZodEnum<{
                    "three-dot": "three-dot";
                    "two-dot": "two-dot";
                    "working-tree": "working-tree";
                    staged: "staged";
                    commit: "commit";
                }>;
                mergeBase: z.ZodOptional<z.ZodString>;
                resolvedBase: z.ZodOptional<z.ZodString>;
                resolvedHead: z.ZodOptional<z.ZodString>;
                describe: z.ZodString;
            }, z.core.$loose>;
            comparison: z.ZodEnum<{
                "merge-base-to-head": "merge-base-to-head";
                "base-to-head": "base-to-head";
                "head-to-index": "head-to-index";
                "head-to-worktree": "head-to-worktree";
            }>;
            includedLayers: z.ZodArray<z.ZodEnum<{
                index: "index";
                committed: "committed";
                worktree: "worktree";
            }>>;
            relativePath: z.ZodOptional<z.ZodString>;
            implicit: z.ZodBoolean;
            indexTreeOid: z.ZodOptional<z.ZodString>;
            untracked: z.ZodEnum<{
                "not-applicable": "not-applicable";
                "excluded-none-observed": "excluded-none-observed";
                "excluded-present": "excluded-present";
            }>;
        }, z.core.$loose>>;
    }, z.core.$loose>>;
    obligations: z.ZodOptional<z.ZodObject<{
        gaps: z.ZodArray<z.ZodObject<{
            entityId: z.ZodString;
            qualifiedName: z.ZodString;
            nearestTestedAncestor: z.ZodNullable<z.ZodString>;
        }, z.core.$loose>>;
        seamCrossings: z.ZodArray<z.ZodString>;
        split: z.ZodObject<{
            logic: z.ZodNumber;
            cosmetic: z.ZodNumber;
        }, z.core.$loose>;
        coverage: z.ZodOptional<z.ZodEnum<{
            partial: "partial";
            complete: "complete";
        }>>;
        evidenceGaps: z.ZodOptional<z.ZodObject<{
            skippedChanges: z.ZodArray<z.ZodObject<{
                qualifiedName: z.ZodString;
                relativePath: z.ZodString;
                reason: z.ZodString;
            }, z.core.$loose>>;
            count: z.ZodNumber;
        }, z.core.$loose>>;
    }, z.core.$loose>>;
}, z.core.$loose>;
export declare const impactOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
    }>;
    entity: z.ZodOptional<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>;
    inlineContext: z.ZodOptional<z.ZodObject<{
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        focusStartLine: z.ZodNumber;
        focusEndLine: z.ZodNumber;
        source: z.ZodString;
    }, z.core.$strip>>;
    scope: z.ZodOptional<z.ZodEnum<{
        all: "all";
        tests: "tests";
        deps: "deps";
        dependents: "dependents";
    }>>;
    coverage: z.ZodOptional<z.ZodEnum<{
        full: "full";
        partial: "partial";
    }>>;
    unreachableEdges: z.ZodOptional<z.ZodNumber>;
    truncated: z.ZodOptional<z.ZodBoolean>;
    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
        entity: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        distance: z.ZodNumber;
        via: z.ZodArray<z.ZodString>;
        selector: z.ZodOptional<z.ZodObject<{
            file: z.ZodString;
            title: z.ZodString;
            suites: z.ZodArray<z.ZodString>;
            fullTitle: z.ZodString;
            framework: z.ZodOptional<z.ZodEnum<{
                jest: "jest";
                mocha: "mocha";
                "node:test": "node:test";
                pytest: "pytest";
                vitest: "vitest";
            }>>;
            command: z.ZodOptional<z.ZodObject<{
                executable: z.ZodString;
                args: z.ZodArray<z.ZodString>;
                cwd: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>>;
        inlineContext: z.ZodOptional<z.ZodObject<{
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            focusStartLine: z.ZodNumber;
            focusEndLine: z.ZodNumber;
            source: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$loose>>>;
    dependents: z.ZodOptional<z.ZodArray<z.ZodObject<{
        entity: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        distance: z.ZodNumber;
        via: z.ZodArray<z.ZodString>;
        selector: z.ZodOptional<z.ZodObject<{
            file: z.ZodString;
            title: z.ZodString;
            suites: z.ZodArray<z.ZodString>;
            fullTitle: z.ZodString;
            framework: z.ZodOptional<z.ZodEnum<{
                jest: "jest";
                mocha: "mocha";
                "node:test": "node:test";
                pytest: "pytest";
                vitest: "vitest";
            }>>;
            command: z.ZodOptional<z.ZodObject<{
                executable: z.ZodString;
                args: z.ZodArray<z.ZodString>;
                cwd: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>>;
        inlineContext: z.ZodOptional<z.ZodObject<{
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            focusStartLine: z.ZodNumber;
            focusEndLine: z.ZodNumber;
            source: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$loose>>>;
    transitive: z.ZodOptional<z.ZodArray<z.ZodObject<{
        entity: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        distance: z.ZodNumber;
        via: z.ZodArray<z.ZodString>;
        selector: z.ZodOptional<z.ZodObject<{
            file: z.ZodString;
            title: z.ZodString;
            suites: z.ZodArray<z.ZodString>;
            fullTitle: z.ZodString;
            framework: z.ZodOptional<z.ZodEnum<{
                jest: "jest";
                mocha: "mocha";
                "node:test": "node:test";
                pytest: "pytest";
                vitest: "vitest";
            }>>;
            command: z.ZodOptional<z.ZodObject<{
                executable: z.ZodString;
                args: z.ZodArray<z.ZodString>;
                cwd: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>>;
        inlineContext: z.ZodOptional<z.ZodObject<{
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            focusStartLine: z.ZodNumber;
            focusEndLine: z.ZodNumber;
            source: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$loose>>>;
    tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
        entity: z.ZodObject<{
            lineageId: z.ZodOptional<z.ZodString>;
            nodeId: z.ZodOptional<z.ZodString>;
            name: z.ZodString;
            kind: z.ZodString;
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            isExported: z.ZodBoolean;
            isTest: z.ZodBoolean;
        }, z.core.$loose>;
        distance: z.ZodNumber;
        via: z.ZodArray<z.ZodString>;
        selector: z.ZodOptional<z.ZodObject<{
            file: z.ZodString;
            title: z.ZodString;
            suites: z.ZodArray<z.ZodString>;
            fullTitle: z.ZodString;
            framework: z.ZodOptional<z.ZodEnum<{
                jest: "jest";
                mocha: "mocha";
                "node:test": "node:test";
                pytest: "pytest";
                vitest: "vitest";
            }>>;
            command: z.ZodOptional<z.ZodObject<{
                executable: z.ZodString;
                args: z.ZodArray<z.ZodString>;
                cwd: z.ZodString;
            }, z.core.$loose>>;
        }, z.core.$loose>>;
        inlineContext: z.ZodOptional<z.ZodObject<{
            relativePath: z.ZodString;
            startLine: z.ZodNumber;
            endLine: z.ZodNumber;
            focusStartLine: z.ZodNumber;
            focusEndLine: z.ZodNumber;
            source: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$loose>>>;
    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const blameOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        not_found: "not_found";
    }>;
    relativePath: z.ZodOptional<z.ZodString>;
    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
        state: z.ZodString;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const logOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
    }>;
    entity: z.ZodOptional<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>;
    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
        commit: z.ZodString;
        changeType: z.ZodString;
    }, z.core.$loose>>>;
    truncated: z.ZodOptional<z.ZodBoolean>;
    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const statusOutputSchema: z.ZodObject<{
    truncated: z.ZodBoolean;
    evidenceComplete: z.ZodBoolean;
    mode: z.ZodString;
    codeIndexSchemaVersion: z.ZodOptional<z.ZodNumber>;
    parserContract: z.ZodOptional<z.ZodObject<{
        parserName: z.ZodString;
        parserVersion: z.ZodNumber;
    }, z.core.$loose>>;
    parserEvidence: z.ZodOptional<z.ZodObject<{
        totalFiles: z.ZodNumber;
        provenanceFiles: z.ZodNumber;
        legacyFiles: z.ZodNumber;
        parserVersions: z.ZodArray<z.ZodNumber>;
        checkerFiles: z.ZodNumber;
        syntaxFiles: z.ZodNumber;
        checkerFallbackFiles: z.ZodNumber;
        recoveredFiles: z.ZodNumber;
        fallbackFiles: z.ZodNumber;
        degradedFiles: z.ZodNumber;
    }, z.core.$loose>>;
    commitsIndexed: z.ZodNumber;
    lineageCount: z.ZodNumber;
    fresh: z.ZodBoolean;
    reasons: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
    }, z.core.$loose>>;
    diagnostics: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
    }, z.core.$loose>>;
}, z.core.$loose>;
export declare const contextOutputSchema: z.ZodObject<{
    status: z.ZodEnum<{
        error: "error";
        resolved: "resolved";
        ambiguous: "ambiguous";
        not_found: "not_found";
    }>;
    refused: z.ZodOptional<z.ZodLiteral<true>>;
    reason: z.ZodOptional<z.ZodLiteral<"token-budget-exceeded">>;
    required: z.ZodOptional<z.ZodNumber>;
    budget: z.ZodOptional<z.ZodNumber>;
    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
        description: z.ZodString;
        argv: z.ZodArray<z.ZodString>;
        projectedTokens: z.ZodNumber;
    }, z.core.$loose>>>;
    entity: z.ZodOptional<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>;
    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
        role: z.ZodString;
        tokens: z.ZodNumber;
        inlineContext: z.ZodOptional<z.ZodObject<{
            startLine: z.ZodNumber;
            relativePath: z.ZodString;
            endLine: z.ZodNumber;
            focusStartLine: z.ZodNumber;
            focusEndLine: z.ZodNumber;
        }, z.core.$strip>>;
    }, z.core.$loose>>>;
    tokenBudget: z.ZodOptional<z.ZodNumber>;
    tokensUsed: z.ZodOptional<z.ZodNumber>;
    truncated: z.ZodOptional<z.ZodBoolean>;
    referenceClosure: z.ZodOptional<z.ZodEnum<{
        unknown: "unknown";
        open: "open";
        closed: "closed";
    }>>;
    referenceClosureReasons: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        "regex-fallback": "regex-fallback";
        "targets-omitted": "targets-omitted";
        "unresolved-edges": "unresolved-edges";
        "unreachable-edges": "unreachable-edges";
        "graph-node-unavailable": "graph-node-unavailable";
        "truncated-entity": "truncated-entity";
    }>>>;
    edgesResolved: z.ZodOptional<z.ZodNumber>;
    edgesUnresolved: z.ZodOptional<z.ZodNumber>;
    targetsOmitted: z.ZodOptional<z.ZodNumber>;
    unreachableEdges: z.ZodOptional<z.ZodNumber>;
    unresolvedHandles: z.ZodOptional<z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<{
            "omitted-target": "omitted-target";
            "unreachable-target": "unreachable-target";
            "unresolved-edge": "unresolved-edge";
            "ambiguous-edge": "ambiguous-edge";
        }>;
        edgeType: z.ZodEnum<{
            imports: "imports";
            calls: "calls";
        }>;
        name: z.ZodString;
        nodeId: z.ZodOptional<z.ZodString>;
        relativePath: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>>>;
    unresolvedHandlesOmitted: z.ZodOptional<z.ZodNumber>;
    candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        lineageId: z.ZodOptional<z.ZodString>;
        nodeId: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        kind: z.ZodString;
        relativePath: z.ZodString;
        startLine: z.ZodNumber;
        endLine: z.ZodNumber;
        isExported: z.ZodBoolean;
        isTest: z.ZodBoolean;
    }, z.core.$loose>>>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export interface EntityToolContext {
    repoRoot: string;
    session: OccEntityIntelligenceSession;
    /** The bounds the session was built with, so `occ_status` can report them. */
    bounds?: EntityBounds;
}
/** What every handler hands back; the caller shapes it into a `CallToolResult`. */
export interface ToolOutcome {
    text: string;
    data: JsonObject;
    isError?: boolean;
}
/**
 * MCP transmits JSON, and every OCC result is a JSON object — but a TypeScript
 * interface carries no index signature, so the compiler cannot see that. This
 * is the one place the boundary is asserted, rather than sprinkling casts
 * through six handlers.
 */
type JsonObject = {
    [key: string]: unknown;
};
/**
 * Confine a client-supplied path to the repository root.
 *
 * The MCP process may be launched by an agent acting on a model's output, so
 * `../../.ssh/id_rsa` is a realistic input rather than a theoretical one. The
 * server applies this *before* it builds a session: refusing an escape must
 * not require indexing a repository first, and the refusal must not depend on
 * anything the session knows.
 */
export declare function guardPath(repoRoot: string, value: string | undefined): {
    relativePath?: string;
} | ToolOutcome;
export declare function isToolOutcome(value: {
    relativePath?: string;
} | ToolOutcome): value is ToolOutcome;
/**
 * Handlers receive the repo-relative path already normalized and confined, so
 * none of them can forget the guard or apply it differently.
 */
export declare function runEntities(args: z.infer<z.ZodObject<typeof entitiesInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runDoc(args: z.infer<z.ZodObject<typeof docInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runSource(args: z.infer<z.ZodObject<typeof sourceInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runPattern(args: z.infer<z.ZodObject<typeof patternInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runHotspots(args: z.infer<z.ZodObject<typeof hotspotsInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runCochange(args: z.infer<z.ZodObject<typeof cochangeInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runDiff(args: z.infer<z.ZodObject<typeof diffInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runImpact(args: z.infer<z.ZodObject<typeof impactInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runBlame(args: z.infer<z.ZodObject<typeof blameInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runLog(args: z.infer<z.ZodObject<typeof logInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
export declare function runContext(args: z.infer<z.ZodObject<typeof contextInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
/**
 * Capture one entity as a verifiable memory anchor.
 *
 * The `nodeId` arm exists for concise-mode clients: the concise projection
 * collapses entity refs to one stable handle preferring `nodeId`, so this is
 * how such a client turns any ref it holds into a durable anchor. The result
 * nests its payload under `anchor`, which the concise projection protects as
 * a subtree — the hash tuple must survive projection or capture is useless.
 */
export declare function runAnchor(args: z.infer<z.ZodObject<typeof anchorInputShape>>, ctx: EntityToolContext, relativePath?: string): Promise<ToolOutcome>;
/**
 * What the index covers, and whether it still describes the repository.
 *
 * The only tool that answers about OCC rather than about the code. Everything
 * else can return an empty result for two incompatible reasons — the repository
 * genuinely has nothing, or the index was starved by its bounds or has gone
 * stale — and this is where a client tells those apart.
 */
export declare function runStatus(args: z.infer<z.ZodObject<typeof statusInputShape>>, ctx: EntityToolContext): Promise<ToolOutcome>;
export {};
