n8n/dist/modules/agents/tools/knowledge/schemas.d.ts

n8n Workflow Automation Tool

import type { JSONSchema7 } from 'json-schema';
import { z } from 'zod';
import type { AgentKnowledgeCommandRequest, AgentKnowledgeCommandResult } from '../../agent-knowledge-command.service';
export declare const DEFAULT_SEARCH_HEAD_LIMIT = 250;
export declare const KNOWLEDGE_OPERATIONS: readonly ["list", "search", "read", "csv_query", "csv_profile", "csv_distinct", "csv_aggregate"];
declare const searchOutputModeSchema: z.ZodEnum<["files_with_matches", "content", "count"]>;
declare const searchMatchModeSchema: z.ZodEnum<["any", "all_on_same_line", "all_within_lines"]>;
export declare const csvFilterSchema: z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
    column: z.ZodString;
    op: z.ZodLiteral<"eq">;
    value: z.ZodString;
}, "strip", z.ZodTypeAny, {
    value: string;
    column: string;
    op: "eq";
}, {
    value: string;
    column: string;
    op: "eq";
}>, z.ZodObject<{
    column: z.ZodString;
    op: z.ZodLiteral<"in">;
    value: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    value: string[];
    column: string;
    op: "in";
}, {
    value: string[];
    column: string;
    op: "in";
}>, z.ZodObject<{
    column: z.ZodString;
    op: z.ZodLiteral<"contains">;
    value: z.ZodString;
}, "strip", z.ZodTypeAny, {
    value: string;
    column: string;
    op: "contains";
}, {
    value: string;
    column: string;
    op: "contains";
}>]>;
export declare const csvQueryInputSchema: z.ZodObject<{
    operation: z.ZodLiteral<"csv_query">;
    file: z.ZodString;
    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    where: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"eq">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "eq";
    }, {
        value: string;
        column: string;
        op: "eq";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"in">;
        value: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        value: string[];
        column: string;
        op: "in";
    }, {
        value: string[];
        column: string;
        op: "in";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"contains">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "contains";
    }, {
        value: string;
        column: string;
        op: "contains";
    }>]>, "many">>;
    rowNumber: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    limit: number;
    file: string;
    operation: "csv_query";
    select?: string[] | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    rowNumber?: number | undefined;
}, {
    file: string;
    operation: "csv_query";
    limit?: number | undefined;
    select?: string[] | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    rowNumber?: number | undefined;
}>;
declare const csvProfileInputSchema: z.ZodObject<{
    operation: z.ZodLiteral<"csv_profile">;
    file: z.ZodString;
    sampleSize: z.ZodDefault<z.ZodNumber>;
    distinctLimit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    file: string;
    operation: "csv_profile";
    sampleSize: number;
    distinctLimit: number;
}, {
    file: string;
    operation: "csv_profile";
    sampleSize?: number | undefined;
    distinctLimit?: number | undefined;
}>;
declare const csvDistinctInputSchema: z.ZodObject<{
    operation: z.ZodLiteral<"csv_distinct">;
    file: z.ZodString;
    column: z.ZodString;
    where: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"eq">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "eq";
    }, {
        value: string;
        column: string;
        op: "eq";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"in">;
        value: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        value: string[];
        column: string;
        op: "in";
    }, {
        value: string[];
        column: string;
        op: "in";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"contains">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "contains";
    }, {
        value: string;
        column: string;
        op: "contains";
    }>]>, "many">>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    limit: number;
    file: string;
    column: string;
    operation: "csv_distinct";
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
}, {
    file: string;
    column: string;
    operation: "csv_distinct";
    limit?: number | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
}>;
declare const csvAggregateInputSchema: z.ZodObject<{
    operation: z.ZodLiteral<"csv_aggregate">;
    file: z.ZodString;
    metric: z.ZodOptional<z.ZodString>;
    metrics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    functions: z.ZodDefault<z.ZodArray<z.ZodEnum<["count", "min", "max", "sum", "avg"]>, "many">>;
    where: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"eq">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "eq";
    }, {
        value: string;
        column: string;
        op: "eq";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"in">;
        value: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        value: string[];
        column: string;
        op: "in";
    }, {
        value: string[];
        column: string;
        op: "in";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"contains">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "contains";
    }, {
        value: string;
        column: string;
        op: "contains";
    }>]>, "many">>;
    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    orderBy: z.ZodOptional<z.ZodObject<{
        column: z.ZodString;
        direction: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
    }, "strict", z.ZodTypeAny, {
        column: string;
        direction: "asc" | "desc";
    }, {
        column: string;
        direction?: "asc" | "desc" | undefined;
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    limit: number;
    file: string;
    operation: "csv_aggregate";
    functions: ("max" | "min" | "count" | "sum" | "avg")[];
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    metrics?: string[] | undefined;
    metric?: string | undefined;
    groupBy?: string[] | undefined;
    orderBy?: {
        column: string;
        direction: "asc" | "desc";
    } | undefined;
}, {
    file: string;
    operation: "csv_aggregate";
    limit?: number | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    metrics?: string[] | undefined;
    functions?: ("max" | "min" | "count" | "sum" | "avg")[] | undefined;
    metric?: string | undefined;
    groupBy?: string[] | undefined;
    orderBy?: {
        column: string;
        direction?: "asc" | "desc" | undefined;
    } | undefined;
}>;
export declare const searchKnowledgeParsingSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObject<{
    operation: z.ZodLiteral<"list">;
}, "strict", z.ZodTypeAny, {
    operation: "list";
}, {
    operation: "list";
}>, z.ZodObject<{
    operation: z.ZodLiteral<"search">;
    query: z.ZodOptional<z.ZodString>;
    queries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    match_mode: z.ZodDefault<z.ZodEnum<["any", "all_on_same_line", "all_within_lines"]>>;
    output_mode: z.ZodDefault<z.ZodEnum<["files_with_matches", "content", "count"]>>;
    caseInsensitive: z.ZodOptional<z.ZodBoolean>;
    fixedStrings: z.ZodOptional<z.ZodBoolean>;
    context: z.ZodOptional<z.ZodNumber>;
    file: z.ZodOptional<z.ZodString>;
    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    offset: z.ZodDefault<z.ZodNumber>;
    head_limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    operation: "search";
    offset: number;
    match_mode: "any" | "all_on_same_line" | "all_within_lines";
    output_mode: "count" | "content" | "files_with_matches";
    head_limit: number;
    query?: string | undefined;
    file?: string | undefined;
    files?: string[] | undefined;
    queries?: string[] | undefined;
    context?: number | undefined;
    caseInsensitive?: boolean | undefined;
    fixedStrings?: boolean | undefined;
}, {
    operation: "search";
    query?: string | undefined;
    file?: string | undefined;
    files?: string[] | undefined;
    offset?: number | undefined;
    queries?: string[] | undefined;
    context?: number | undefined;
    caseInsensitive?: boolean | undefined;
    fixedStrings?: boolean | undefined;
    match_mode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
    output_mode?: "count" | "content" | "files_with_matches" | undefined;
    head_limit?: number | undefined;
}>, z.ZodObject<{
    operation: z.ZodLiteral<"read">;
    file: z.ZodString;
    lineRange: z.ZodOptional<z.ZodObject<{
        start: z.ZodNumber;
        end: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        end: number;
        start: number;
    }, {
        end: number;
        start: number;
    }>>;
}, "strict", z.ZodTypeAny, {
    file: string;
    operation: "read";
    lineRange?: {
        end: number;
        start: number;
    } | undefined;
}, {
    file: string;
    operation: "read";
    lineRange?: {
        end: number;
        start: number;
    } | undefined;
}>, z.ZodObject<{
    operation: z.ZodLiteral<"csv_query">;
    file: z.ZodString;
    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    where: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"eq">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "eq";
    }, {
        value: string;
        column: string;
        op: "eq";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"in">;
        value: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        value: string[];
        column: string;
        op: "in";
    }, {
        value: string[];
        column: string;
        op: "in";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"contains">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "contains";
    }, {
        value: string;
        column: string;
        op: "contains";
    }>]>, "many">>;
    rowNumber: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    limit: number;
    file: string;
    operation: "csv_query";
    select?: string[] | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    rowNumber?: number | undefined;
}, {
    file: string;
    operation: "csv_query";
    limit?: number | undefined;
    select?: string[] | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    rowNumber?: number | undefined;
}>, z.ZodObject<{
    operation: z.ZodLiteral<"csv_profile">;
    file: z.ZodString;
    sampleSize: z.ZodDefault<z.ZodNumber>;
    distinctLimit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    file: string;
    operation: "csv_profile";
    sampleSize: number;
    distinctLimit: number;
}, {
    file: string;
    operation: "csv_profile";
    sampleSize?: number | undefined;
    distinctLimit?: number | undefined;
}>, z.ZodObject<{
    operation: z.ZodLiteral<"csv_distinct">;
    file: z.ZodString;
    column: z.ZodString;
    where: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"eq">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "eq";
    }, {
        value: string;
        column: string;
        op: "eq";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"in">;
        value: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        value: string[];
        column: string;
        op: "in";
    }, {
        value: string[];
        column: string;
        op: "in";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"contains">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "contains";
    }, {
        value: string;
        column: string;
        op: "contains";
    }>]>, "many">>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    limit: number;
    file: string;
    column: string;
    operation: "csv_distinct";
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
}, {
    file: string;
    column: string;
    operation: "csv_distinct";
    limit?: number | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
}>, z.ZodObject<{
    operation: z.ZodLiteral<"csv_aggregate">;
    file: z.ZodString;
    metric: z.ZodOptional<z.ZodString>;
    metrics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    functions: z.ZodDefault<z.ZodArray<z.ZodEnum<["count", "min", "max", "sum", "avg"]>, "many">>;
    where: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"eq">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "eq";
    }, {
        value: string;
        column: string;
        op: "eq";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"in">;
        value: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        value: string[];
        column: string;
        op: "in";
    }, {
        value: string[];
        column: string;
        op: "in";
    }>, z.ZodObject<{
        column: z.ZodString;
        op: z.ZodLiteral<"contains">;
        value: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        column: string;
        op: "contains";
    }, {
        value: string;
        column: string;
        op: "contains";
    }>]>, "many">>;
    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    orderBy: z.ZodOptional<z.ZodObject<{
        column: z.ZodString;
        direction: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
    }, "strict", z.ZodTypeAny, {
        column: string;
        direction: "asc" | "desc";
    }, {
        column: string;
        direction?: "asc" | "desc" | undefined;
    }>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strict", z.ZodTypeAny, {
    limit: number;
    file: string;
    operation: "csv_aggregate";
    functions: ("max" | "min" | "count" | "sum" | "avg")[];
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    metrics?: string[] | undefined;
    metric?: string | undefined;
    groupBy?: string[] | undefined;
    orderBy?: {
        column: string;
        direction: "asc" | "desc";
    } | undefined;
}, {
    file: string;
    operation: "csv_aggregate";
    limit?: number | undefined;
    where?: ({
        value: string;
        column: string;
        op: "eq";
    } | {
        value: string[];
        column: string;
        op: "in";
    } | {
        value: string;
        column: string;
        op: "contains";
    })[] | undefined;
    metrics?: string[] | undefined;
    functions?: ("max" | "min" | "count" | "sum" | "avg")[] | undefined;
    metric?: string | undefined;
    groupBy?: string[] | undefined;
    orderBy?: {
        column: string;
        direction?: "asc" | "desc" | undefined;
    } | undefined;
}>]>;
export declare const searchKnowledgeInputSchema: JSONSchema7;
declare const searchMatchOutputSchema: z.ZodObject<{
    fileId: z.ZodString;
    fileName: z.ZodString;
    relativePath: z.ZodString;
    lineNumber: z.ZodNumber;
    text: z.ZodString;
    readRange: z.ZodObject<{
        start: z.ZodNumber;
        end: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        end: number;
        start: number;
    }, {
        end: number;
        start: number;
    }>;
    truncated: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    fileName: string;
    text: string;
    fileId: string;
    lineNumber: number;
    relativePath: string;
    readRange: {
        end: number;
        start: number;
    };
    truncated?: boolean | undefined;
}, {
    fileName: string;
    text: string;
    fileId: string;
    lineNumber: number;
    relativePath: string;
    readRange: {
        end: number;
        start: number;
    };
    truncated?: boolean | undefined;
}>;
declare const searchResultOutputSchema: z.ZodObject<{
    mode: z.ZodEnum<["files_with_matches", "content", "count"]>;
    query: z.ZodString;
    queries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    matchMode: z.ZodOptional<z.ZodEnum<["any", "all_on_same_line", "all_within_lines"]>>;
    totalMatchingFiles: z.ZodNumber;
    totalMatchingLines: z.ZodNumber;
    files: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        fileName: z.ZodString;
        relativePath: z.ZodString;
        matchCount: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        fileName: string;
        id: string;
        relativePath: string;
        matchCount: number;
    }, {
        fileName: string;
        id: string;
        relativePath: string;
        matchCount: number;
    }>, "many">;
    matches: z.ZodArray<z.ZodObject<{
        fileId: z.ZodString;
        fileName: z.ZodString;
        relativePath: z.ZodString;
        lineNumber: z.ZodNumber;
        text: z.ZodString;
        readRange: z.ZodObject<{
            start: z.ZodNumber;
            end: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            end: number;
            start: number;
        }, {
            end: number;
            start: number;
        }>;
        truncated: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        fileName: string;
        text: string;
        fileId: string;
        lineNumber: number;
        relativePath: string;
        readRange: {
            end: number;
            start: number;
        };
        truncated?: boolean | undefined;
    }, {
        fileName: string;
        text: string;
        fileId: string;
        lineNumber: number;
        relativePath: string;
        readRange: {
            end: number;
            start: number;
        };
        truncated?: boolean | undefined;
    }>, "many">;
    truncated: z.ZodBoolean;
    appliedLimit: z.ZodOptional<z.ZodNumber>;
    appliedOffset: z.ZodOptional<z.ZodNumber>;
    nextOffset: z.ZodOptional<z.ZodNumber>;
    hint: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    query: string;
    files: {
        fileName: string;
        id: string;
        relativePath: string;
        matchCount: number;
    }[];
    mode: "count" | "content" | "files_with_matches";
    truncated: boolean;
    totalMatchingFiles: number;
    totalMatchingLines: number;
    matches: {
        fileName: string;
        text: string;
        fileId: string;
        lineNumber: number;
        relativePath: string;
        readRange: {
            end: number;
            start: number;
        };
        truncated?: boolean | undefined;
    }[];
    hint?: string | undefined;
    queries?: string[] | undefined;
    matchMode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
    appliedLimit?: number | undefined;
    appliedOffset?: number | undefined;
    nextOffset?: number | undefined;
}, {
    query: string;
    files: {
        fileName: string;
        id: string;
        relativePath: string;
        matchCount: number;
    }[];
    mode: "count" | "content" | "files_with_matches";
    truncated: boolean;
    totalMatchingFiles: number;
    totalMatchingLines: number;
    matches: {
        fileName: string;
        text: string;
        fileId: string;
        lineNumber: number;
        relativePath: string;
        readRange: {
            end: number;
            start: number;
        };
        truncated?: boolean | undefined;
    }[];
    hint?: string | undefined;
    queries?: string[] | undefined;
    matchMode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
    appliedLimit?: number | undefined;
    appliedOffset?: number | undefined;
    nextOffset?: number | undefined;
}>;
export declare const searchKnowledgeOutputSchema: z.ZodObject<{
    operation: z.ZodEnum<["list", "search", "read", "csv_query", "csv_profile", "csv_distinct", "csv_aggregate"]>;
    files: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        fileName: z.ZodString;
        mimeType: z.ZodString;
        fileSizeBytes: z.ZodNumber;
        relativePath: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        fileName: string;
        id: string;
        mimeType: string;
        fileSizeBytes: number;
        relativePath: string;
    }, {
        fileName: string;
        id: string;
        mimeType: string;
        fileSizeBytes: number;
        relativePath: string;
    }>, "many">;
    result: z.ZodOptional<z.ZodObject<{
        command: z.ZodEnum<["git_grep", "cat", "sed"]>;
        exitCode: z.ZodNullable<z.ZodNumber>;
        stdout: z.ZodString;
        stderr: z.ZodString;
        truncated: z.ZodBoolean;
        citation: z.ZodOptional<z.ZodObject<{
            fileName: z.ZodString;
            lineRange: z.ZodOptional<z.ZodObject<{
                start: z.ZodNumber;
                end: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                end: number;
                start: number;
            }, {
                end: number;
                start: number;
            }>>;
            instruction: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            fileName: string;
            instruction: string;
            lineRange?: {
                end: number;
                start: number;
            } | undefined;
        }, {
            fileName: string;
            instruction: string;
            lineRange?: {
                end: number;
                start: number;
            } | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        command: "git_grep" | "cat" | "sed";
        stdout: string;
        exitCode: number | null;
        stderr: string;
        truncated: boolean;
        citation?: {
            fileName: string;
            instruction: string;
            lineRange?: {
                end: number;
                start: number;
            } | undefined;
        } | undefined;
    }, {
        command: "git_grep" | "cat" | "sed";
        stdout: string;
        exitCode: number | null;
        stderr: string;
        truncated: boolean;
        citation?: {
            fileName: string;
            instruction: string;
            lineRange?: {
                end: number;
                start: number;
            } | undefined;
        } | undefined;
    }>>;
    search: z.ZodOptional<z.ZodObject<{
        mode: z.ZodEnum<["files_with_matches", "content", "count"]>;
        query: z.ZodString;
        queries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        matchMode: z.ZodOptional<z.ZodEnum<["any", "all_on_same_line", "all_within_lines"]>>;
        totalMatchingFiles: z.ZodNumber;
        totalMatchingLines: z.ZodNumber;
        files: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            fileName: z.ZodString;
            relativePath: z.ZodString;
            matchCount: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            fileName: string;
            id: string;
            relativePath: string;
            matchCount: number;
        }, {
            fileName: string;
            id: string;
            relativePath: string;
            matchCount: number;
        }>, "many">;
        matches: z.ZodArray<z.ZodObject<{
            fileId: z.ZodString;
            fileName: z.ZodString;
            relativePath: z.ZodString;
            lineNumber: z.ZodNumber;
            text: z.ZodString;
            readRange: z.ZodObject<{
                start: z.ZodNumber;
                end: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                end: number;
                start: number;
            }, {
                end: number;
                start: number;
            }>;
            truncated: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            fileName: string;
            text: string;
            fileId: string;
            lineNumber: number;
            relativePath: string;
            readRange: {
                end: number;
                start: number;
            };
            truncated?: boolean | undefined;
        }, {
            fileName: string;
            text: string;
            fileId: string;
            lineNumber: number;
            relativePath: string;
            readRange: {
                end: number;
                start: number;
            };
            truncated?: boolean | undefined;
        }>, "many">;
        truncated: z.ZodBoolean;
        appliedLimit: z.ZodOptional<z.ZodNumber>;
        appliedOffset: z.ZodOptional<z.ZodNumber>;
        nextOffset: z.ZodOptional<z.ZodNumber>;
        hint: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        query: string;
        files: {
            fileName: string;
            id: string;
            relativePath: string;
            matchCount: number;
        }[];
        mode: "count" | "content" | "files_with_matches";
        truncated: boolean;
        totalMatchingFiles: number;
        totalMatchingLines: number;
        matches: {
            fileName: string;
            text: string;
            fileId: string;
            lineNumber: number;
            relativePath: string;
            readRange: {
                end: number;
                start: number;
            };
            truncated?: boolean | undefined;
        }[];
        hint?: string | undefined;
        queries?: string[] | undefined;
        matchMode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
        appliedLimit?: number | undefined;
        appliedOffset?: number | undefined;
        nextOffset?: number | undefined;
    }, {
        query: string;
        files: {
            fileName: string;
            id: string;
            relativePath: string;
            matchCount: number;
        }[];
        mode: "count" | "content" | "files_with_matches";
        truncated: boolean;
        totalMatchingFiles: number;
        totalMatchingLines: number;
        matches: {
            fileName: string;
            text: string;
            fileId: string;
            lineNumber: number;
            relativePath: string;
            readRange: {
                end: number;
                start: number;
            };
            truncated?: boolean | undefined;
        }[];
        hint?: string | undefined;
        queries?: string[] | undefined;
        matchMode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
        appliedLimit?: number | undefined;
        appliedOffset?: number | undefined;
        nextOffset?: number | undefined;
    }>>;
    csv: z.ZodOptional<z.ZodObject<{
        fileName: z.ZodString;
        relativePath: z.ZodString;
        columns: z.ZodArray<z.ZodString, "many">;
        rowNumbers: z.ZodArray<z.ZodNumber, "many">;
        rows: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
        records: z.ZodOptional<z.ZodArray<z.ZodObject<{
            rowNumber: z.ZodNumber;
            fileLineNumber: z.ZodNumber;
            values: z.ZodRecord<z.ZodString, z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            values: Record<string, string>;
            rowNumber: number;
            fileLineNumber: number;
        }, {
            values: Record<string, string>;
            rowNumber: number;
            fileLineNumber: number;
        }>, "many">>;
        rowCount: z.ZodNumber;
        truncated: z.ZodBoolean;
        rowNumberBase: z.ZodOptional<z.ZodString>;
        ambiguity: z.ZodOptional<z.ZodObject<{
            matchedRows: z.ZodNumber;
            message: z.ZodString;
            suggestedColumns: z.ZodArray<z.ZodString, "many">;
            sampleDistinctValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
        }, "strip", z.ZodTypeAny, {
            message: string;
            matchedRows: number;
            suggestedColumns: string[];
            sampleDistinctValues?: Record<string, string[]> | undefined;
        }, {
            message: string;
            matchedRows: number;
            suggestedColumns: string[];
            sampleDistinctValues?: Record<string, string[]> | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        fileName: string;
        rows: string[][];
        columns: string[];
        rowCount: number;
        truncated: boolean;
        relativePath: string;
        rowNumbers: number[];
        records?: {
            values: Record<string, string>;
            rowNumber: number;
            fileLineNumber: number;
        }[] | undefined;
        rowNumberBase?: string | undefined;
        ambiguity?: {
            message: string;
            matchedRows: number;
            suggestedColumns: string[];
            sampleDistinctValues?: Record<string, string[]> | undefined;
        } | undefined;
    }, {
        fileName: string;
        rows: string[][];
        columns: string[];
        rowCount: number;
        truncated: boolean;
        relativePath: string;
        rowNumbers: number[];
        records?: {
            values: Record<string, string>;
            rowNumber: number;
            fileLineNumber: number;
        }[] | undefined;
        rowNumberBase?: string | undefined;
        ambiguity?: {
            message: string;
            matchedRows: number;
            suggestedColumns: string[];
            sampleDistinctValues?: Record<string, string[]> | undefined;
        } | undefined;
    }>>;
    csvProfile: z.ZodOptional<z.ZodObject<{
        fileName: z.ZodString;
        relativePath: z.ZodString;
        columns: z.ZodArray<z.ZodString, "many">;
        rowCount: z.ZodNumber;
        sampleRows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>, "many">;
        columnProfiles: z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            inferredType: z.ZodEnum<["empty", "integer", "number", "boolean", "date", "string"]>;
            emptyCount: z.ZodNumber;
            distinctCount: z.ZodOptional<z.ZodNumber>;
            distinctCountTruncated: z.ZodOptional<z.ZodBoolean>;
            sampleValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            name: string;
            inferredType: "string" | "number" | "boolean" | "empty" | "date" | "integer";
            emptyCount: number;
            distinctCount?: number | undefined;
            distinctCountTruncated?: boolean | undefined;
            sampleValues?: string[] | undefined;
        }, {
            name: string;
            inferredType: "string" | "number" | "boolean" | "empty" | "date" | "integer";
            emptyCount: number;
            distinctCount?: number | undefined;
            distinctCountTruncated?: boolean | undefined;
            sampleValues?: string[] | undefined;
        }>, "many">;
        likelyKeyColumns: z.ZodArray<z.ZodString, "many">;
        likelyDisambiguatingColumns: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        fileName: string;
        columns: string[];
        rowCount: number;
        relativePath: string;
        sampleRows: Record<string, string>[];
        columnProfiles: {
            name: string;
            inferredType: "string" | "number" | "boolean" | "empty" | "date" | "integer";
            emptyCount: number;
            distinctCount?: number | undefined;
            distinctCountTruncated?: boolean | undefined;
            sampleValues?: string[] | undefined;
        }[];
        likelyKeyColumns: string[];
        likelyDisambiguatingColumns: string[];
    }, {
        fileName: string;
        columns: string[];
        rowCount: number;
        relativePath: string;
        sampleRows: Record<string, string>[];
        columnProfiles: {
            name: string;
            inferredType: "string" | "number" | "boolean" | "empty" | "date" | "integer";
            emptyCount: number;
            distinctCount?: number | undefined;
            distinctCountTruncated?: boolean | undefined;
            sampleValues?: string[] | undefined;
        }[];
        likelyKeyColumns: string[];
        likelyDisambiguatingColumns: string[];
    }>>;
    csvDistinct: z.ZodOptional<z.ZodObject<{
        fileName: z.ZodString;
        relativePath: z.ZodString;
        column: z.ZodString;
        values: z.ZodArray<z.ZodString, "many">;
        distinctCount: z.ZodNumber;
        truncated: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        values: string[];
        fileName: string;
        column: string;
        truncated: boolean;
        relativePath: string;
        distinctCount: number;
    }, {
        values: string[];
        fileName: string;
        column: string;
        truncated: boolean;
        relativePath: string;
        distinctCount: number;
    }>>;
    csvAggregate: z.ZodOptional<z.ZodObject<{
        fileName: z.ZodString;
        relativePath: z.ZodString;
        rowCount: z.ZodNumber;
        functions: z.ZodArray<z.ZodEnum<["count", "min", "max", "sum", "avg"]>, "many">;
        metrics: z.ZodArray<z.ZodString, "many">;
        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        results: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>, "many">;
        truncated: z.ZodBoolean;
        skippedNonNumeric: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    }, "strip", z.ZodTypeAny, {
        fileName: string;
        metrics: string[];
        results: Record<string, string | number | null>[];
        rowCount: number;
        functions: ("max" | "min" | "count" | "sum" | "avg")[];
        truncated: boolean;
        relativePath: string;
        groupBy?: string[] | undefined;
        skippedNonNumeric?: Record<string, number> | undefined;
    }, {
        fileName: string;
        metrics: string[];
        results: Record<string, string | number | null>[];
        rowCount: number;
        functions: ("max" | "min" | "count" | "sum" | "avg")[];
        truncated: boolean;
        relativePath: string;
        groupBy?: string[] | undefined;
        skippedNonNumeric?: Record<string, number> | undefined;
    }>>;
    error: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    files: {
        fileName: string;
        id: string;
        mimeType: string;
        fileSizeBytes: number;
        relativePath: string;
    }[];
    operation: "search" | "read" | "list" | "csv_query" | "csv_profile" | "csv_distinct" | "csv_aggregate";
    search?: {
        query: string;
        files: {
            fileName: string;
            id: string;
            relativePath: string;
            matchCount: number;
        }[];
        mode: "count" | "content" | "files_with_matches";
        truncated: boolean;
        totalMatchingFiles: number;
        totalMatchingLines: number;
        matches: {
            fileName: string;
            text: string;
            fileId: string;
            lineNumber: number;
            relativePath: string;
            readRange: {
                end: number;
                start: number;
            };
            truncated?: boolean | undefined;
        }[];
        hint?: string | undefined;
        queries?: string[] | undefined;
        matchMode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
        appliedLimit?: number | undefined;
        appliedOffset?: number | undefined;
        nextOffset?: number | undefined;
    } | undefined;
    error?: string | undefined;
    result?: {
        command: "git_grep" | "cat" | "sed";
        stdout: string;
        exitCode: number | null;
        stderr: string;
        truncated: boolean;
        citation?: {
            fileName: string;
            instruction: string;
            lineRange?: {
                end: number;
                start: number;
            } | undefined;
        } | undefined;
    } | undefined;
    csv?: {
        fileName: string;
        rows: string[][];
        columns: string[];
        rowCount: number;
        truncated: boolean;
        relativePath: string;
        rowNumbers: number[];
        records?: {
            values: Record<string, string>;
            rowNumber: number;
            fileLineNumber: number;
        }[] | undefined;
        rowNumberBase?: string | undefined;
        ambiguity?: {
            message: string;
            matchedRows: number;
            suggestedColumns: string[];
            sampleDistinctValues?: Record<string, string[]> | undefined;
        } | undefined;
    } | undefined;
    csvProfile?: {
        fileName: string;
        columns: string[];
        rowCount: number;
        relativePath: string;
        sampleRows: Record<string, string>[];
        columnProfiles: {
            name: string;
            inferredType: "string" | "number" | "boolean" | "empty" | "date" | "integer";
            emptyCount: number;
            distinctCount?: number | undefined;
            distinctCountTruncated?: boolean | undefined;
            sampleValues?: string[] | undefined;
        }[];
        likelyKeyColumns: string[];
        likelyDisambiguatingColumns: string[];
    } | undefined;
    csvDistinct?: {
        values: string[];
        fileName: string;
        column: string;
        truncated: boolean;
        relativePath: string;
        distinctCount: number;
    } | undefined;
    csvAggregate?: {
        fileName: string;
        metrics: string[];
        results: Record<string, string | number | null>[];
        rowCount: number;
        functions: ("max" | "min" | "count" | "sum" | "avg")[];
        truncated: boolean;
        relativePath: string;
        groupBy?: string[] | undefined;
        skippedNonNumeric?: Record<string, number> | undefined;
    } | undefined;
}, {
    files: {
        fileName: string;
        id: string;
        mimeType: string;
        fileSizeBytes: number;
        relativePath: string;
    }[];
    operation: "search" | "read" | "list" | "csv_query" | "csv_profile" | "csv_distinct" | "csv_aggregate";
    search?: {
        query: string;
        files: {
            fileName: string;
            id: string;
            relativePath: string;
            matchCount: number;
        }[];
        mode: "count" | "content" | "files_with_matches";
        truncated: boolean;
        totalMatchingFiles: number;
        totalMatchingLines: number;
        matches: {
            fileName: string;
            text: string;
            fileId: string;
            lineNumber: number;
            relativePath: string;
            readRange: {
                end: number;
                start: number;
            };
            truncated?: boolean | undefined;
        }[];
        hint?: string | undefined;
        queries?: string[] | undefined;
        matchMode?: "any" | "all_on_same_line" | "all_within_lines" | undefined;
        appliedLimit?: number | undefined;
        appliedOffset?: number | undefined;
        nextOffset?: number | undefined;
    } | undefined;
    error?: string | undefined;
    result?: {
        command: "git_grep" | "cat" | "sed";
        stdout: string;
        exitCode: number | null;
        stderr: string;
        truncated: boolean;
        citation?: {
            fileName: string;
            instruction: string;
            lineRange?: {
                end: number;
                start: number;
            } | undefined;
        } | undefined;
    } | undefined;
    csv?: {
        fileName: string;
        rows: string[][];
        columns: string[];
        rowCount: number;
        truncated: boolean;
        relativePath: string;
        rowNumbers: number[];
        records?: {
            values: Record<string, string>;
            rowNumber: number;
            fileLineNumber: number;
        }[] | undefined;
        rowNumberBase?: string | undefined;
        ambiguity?: {
            message: string;
            matchedRows: number;
            suggestedColumns: string[];
            sampleDistinctValues?: Record<string, string[]> | undefined;
        } | undefined;
    } | undefined;
    csvProfile?: {
        fileName: string;
        columns: string[];
        rowCount: number;
        relativePath: string;
        sampleRows: Record<string, string>[];
        columnProfiles: {
            name: string;
            inferredType: "string" | "number" | "boolean" | "empty" | "date" | "integer";
            emptyCount: number;
            distinctCount?: number | undefined;
            distinctCountTruncated?: boolean | undefined;
            sampleValues?: string[] | undefined;
        }[];
        likelyKeyColumns: string[];
        likelyDisambiguatingColumns: string[];
    } | undefined;
    csvDistinct?: {
        values: string[];
        fileName: string;
        column: string;
        truncated: boolean;
        relativePath: string;
        distinctCount: number;
    } | undefined;
    csvAggregate?: {
        fileName: string;
        metrics: string[];
        results: Record<string, string | number | null>[];
        rowCount: number;
        functions: ("max" | "min" | "count" | "sum" | "avg")[];
        truncated: boolean;
        relativePath: string;
        groupBy?: string[] | undefined;
        skippedNonNumeric?: Record<string, number> | undefined;
    } | undefined;
}>;
export type ParsedSearchKnowledgeInput = z.infer<typeof searchKnowledgeParsingSchema>;
export type SearchKnowledgeOutput = z.infer<typeof searchKnowledgeOutputSchema>;
export type CsvQueryInput = z.infer<typeof csvQueryInputSchema>;
export type CsvProfileInput = z.infer<typeof csvProfileInputSchema>;
export type CsvDistinctInput = z.infer<typeof csvDistinctInputSchema>;
export type CsvAggregateInput = z.infer<typeof csvAggregateInputSchema>;
export type CsvFilter = z.infer<typeof csvFilterSchema>;
export type SearchOutputMode = z.infer<typeof searchOutputModeSchema>;
export type SearchMatchMode = z.infer<typeof searchMatchModeSchema>;
export type SearchMatchOutput = z.infer<typeof searchMatchOutputSchema>;
export type SearchResultOutput = z.infer<typeof searchResultOutputSchema>;
export type InternalKnowledgeCommandRequest = Extract<AgentKnowledgeCommandRequest, {
    command: 'git_grep' | 'cat' | 'sed';
}>;
export type InternalKnowledgeCommandResult = Omit<AgentKnowledgeCommandResult, 'command'> & {
    command: InternalKnowledgeCommandRequest['command'];
};
export declare function parseSearchKnowledgeInput(input: unknown): ParsedSearchKnowledgeInput;
export declare function getSearchKnowledgeOperation(input: unknown): SearchKnowledgeOutput['operation'];
export {};