/**
 * OCR Provenance MCP System - Zod Validation Schemas
 *
 * This module provides comprehensive input validation for all MCP tool inputs.
 * Each schema includes:
 * - Type validation
 * - Constraint validation (min/max, patterns, etc.)
 * - Descriptive error messages
 * - Default values where appropriate
 *
 * @module utils/validation
 */
import { z } from 'zod';
/**
 * Custom validation error with descriptive message
 */
export declare class ValidationError extends Error {
    constructor(message: string);
}
/**
 * Validate input against schema and throw descriptive error if invalid
 *
 * @param schema - Zod schema to validate against
 * @param input - Input value to validate
 * @returns Validated and typed input data
 * @throws ValidationError with descriptive message if validation fails
 */
export declare function validateInput<T>(schema: z.ZodSchema<T>, input: unknown): T;
/**
 * Validate that user-supplied text does not contain HTML/script injection vectors.
 *
 * Rejects:
 * - Strings containing `<` or `>` (HTML tags)
 * - Strings containing `javascript:` (URI scheme)
 * - Strings containing DOM event handler patterns (onclick=, onerror=, etc.)
 *
 * @param value - The string to validate
 * @returns The string unchanged if clean
 * @throws ValidationError if the string contains prohibited characters/patterns
 */
export declare function sanitizeUserText(value: string): string;
/**
 * Zod refinement helper that rejects strings containing HTML/script injection vectors.
 * Use as: z.string().refine(...noHtmlChars())
 *
 * @returns A tuple of [predicate, options] suitable for spreading into z.refine()
 */
export declare function noHtmlChars(): [
    (val: string) => boolean,
    {
        message: string;
    }
];
/**
 * Regex for safe tag name characters: alphanumeric, spaces, hyphens, underscores,
 * and common punctuation (.,:;!?@#&()).
 */
export declare const SAFE_TAG_NAME_REGEX: RegExp;
/**
 * OCR processing mode enum
 */
export declare const OCRMode: z.ZodEnum<["fast", "balanced", "accurate"]>;
/**
 * Item type for provenance lookups
 */
export declare const ItemType: z.ZodEnum<["document", "ocr_result", "chunk", "embedding", "image", "comparison", "clustering", "form_fill", "extraction", "auto"]>;
/**
 * Export format for provenance data
 */
export declare const ExportFormat: z.ZodEnum<["json", "w3c-prov", "csv"]>;
/**
 * Export scope for provenance exports
 */
export declare const ExportScope: z.ZodEnum<["document", "database"]>;
/**
 * Configuration keys that can be set
 */
export declare const ConfigKey: z.ZodEnum<["ocr_default_mode", "ocr_max_concurrent", "embedding_batch_size", "embedding_device", "chunk_size", "chunk_overlap_percent", "max_chunk_size", "auto_cluster_enabled", "auto_cluster_threshold", "auto_cluster_algorithm"]>;
/**
 * Schema for creating a new database
 */
export declare const DatabaseCreateInput: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
    storage_path: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    tags?: string[] | undefined;
    description?: string | undefined;
    storage_path?: string | undefined;
    metadata?: Record<string, string> | undefined;
}, {
    name: string;
    tags?: string[] | undefined;
    description?: string | undefined;
    storage_path?: string | undefined;
    metadata?: Record<string, string> | undefined;
}>;
/**
 * Schema for listing databases
 */
export declare const DatabaseListInput: z.ZodObject<{
    include_stats: z.ZodDefault<z.ZodBoolean>;
    limit: z.ZodDefault<z.ZodNumber>;
    offset: z.ZodDefault<z.ZodNumber>;
    filter_name: z.ZodOptional<z.ZodString>;
    filter_tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    filter_status: z.ZodDefault<z.ZodEnum<["active", "archived", "all"]>>;
    sort_by: z.ZodDefault<z.ZodEnum<["name", "created", "modified", "last_accessed", "size"]>>;
    sort_order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    offset: number;
    include_stats: boolean;
    filter_status: "active" | "archived" | "all";
    sort_by: "name" | "created" | "modified" | "last_accessed" | "size";
    sort_order: "asc" | "desc";
    filter_name?: string | undefined;
    filter_tags?: string[] | undefined;
}, {
    limit?: number | undefined;
    offset?: number | undefined;
    include_stats?: boolean | undefined;
    filter_name?: string | undefined;
    filter_tags?: string[] | undefined;
    filter_status?: "active" | "archived" | "all" | undefined;
    sort_by?: "name" | "created" | "modified" | "last_accessed" | "size" | undefined;
    sort_order?: "asc" | "desc" | undefined;
}>;
/**
 * Schema for selecting a database
 */
export declare const DatabaseSelectInput: z.ZodObject<{
    database_name: z.ZodString;
    force: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    database_name: string;
    force?: boolean | undefined;
}, {
    database_name: string;
    force?: boolean | undefined;
}>;
/**
 * Schema for getting database statistics
 */
export declare const DatabaseStatsInput: z.ZodObject<{
    database_name: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    database_name?: string | undefined;
}, {
    database_name?: string | undefined;
}>;
/**
 * Schema for deleting a database
 */
export declare const DatabaseDeleteInput: z.ZodObject<{
    database_name: z.ZodString;
    confirm: z.ZodLiteral<true>;
}, "strip", z.ZodTypeAny, {
    database_name: string;
    confirm: true;
}, {
    database_name: string;
    confirm: true;
}>;
/**
 * Default supported file types for ingestion
 */
export declare const DEFAULT_FILE_TYPES: string[];
/**
 * Schema for ingesting a directory
 */
export declare const IngestDirectoryInput: z.ZodObject<{
    directory_path: z.ZodString;
    recursive: z.ZodDefault<z.ZodBoolean>;
    file_types: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    include_hidden: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    recursive: boolean;
    directory_path: string;
    file_types: string[];
    include_hidden: boolean;
}, {
    directory_path: string;
    recursive?: boolean | undefined;
    file_types?: string[] | undefined;
    include_hidden?: boolean | undefined;
}>;
/**
 * Schema for ingesting specific files
 */
export declare const IngestFilesInput: z.ZodObject<{
    file_paths: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    file_paths: string[];
}, {
    file_paths: string[];
}>;
/**
 * Schema for processing pending documents
 */
export declare const ProcessPendingInput: z.ZodObject<{
    max_concurrent: z.ZodDefault<z.ZodNumber>;
    ocr_mode: z.ZodOptional<z.ZodEnum<["fast", "balanced", "accurate"]>>;
    max_pages: z.ZodOptional<z.ZodNumber>;
    page_range: z.ZodOptional<z.ZodString>;
    skip_cache: z.ZodOptional<z.ZodBoolean>;
    disable_image_extraction: z.ZodOptional<z.ZodBoolean>;
    extras: z.ZodOptional<z.ZodArray<z.ZodEnum<["track_changes", "chart_understanding", "extract_links", "table_row_bboxes", "infographic", "new_block_types"]>, "many">>;
    page_schema: z.ZodOptional<z.ZodString>;
    additional_config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    max_concurrent: number;
    page_range?: string | undefined;
    ocr_mode?: "fast" | "balanced" | "accurate" | undefined;
    max_pages?: number | undefined;
    skip_cache?: boolean | undefined;
    disable_image_extraction?: boolean | undefined;
    extras?: ("track_changes" | "chart_understanding" | "extract_links" | "table_row_bboxes" | "infographic" | "new_block_types")[] | undefined;
    page_schema?: string | undefined;
    additional_config?: Record<string, unknown> | undefined;
}, {
    page_range?: string | undefined;
    ocr_mode?: "fast" | "balanced" | "accurate" | undefined;
    max_concurrent?: number | undefined;
    max_pages?: number | undefined;
    skip_cache?: boolean | undefined;
    disable_image_extraction?: boolean | undefined;
    extras?: ("track_changes" | "chart_understanding" | "extract_links" | "table_row_bboxes" | "infographic" | "new_block_types")[] | undefined;
    page_schema?: string | undefined;
    additional_config?: Record<string, unknown> | undefined;
}>;
/**
 * Schema for checking OCR status
 */
export declare const OCRStatusInput: z.ZodObject<{
    document_id: z.ZodOptional<z.ZodString>;
    status_filter: z.ZodDefault<z.ZodEnum<["pending", "processing", "complete", "failed", "all"]>>;
}, "strip", z.ZodTypeAny, {
    status_filter: "pending" | "processing" | "complete" | "failed" | "all";
    document_id?: string | undefined;
}, {
    document_id?: string | undefined;
    status_filter?: "pending" | "processing" | "complete" | "failed" | "all" | undefined;
}>;
/**
 * Metadata filter for filtering search results by document metadata
 */
export declare const MetadataFilter: z.ZodOptional<z.ZodObject<{
    doc_title: z.ZodOptional<z.ZodString>;
    doc_author: z.ZodOptional<z.ZodString>;
    doc_subject: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    doc_title?: string | undefined;
    doc_author?: string | undefined;
    doc_subject?: string | undefined;
}, {
    doc_title?: string | undefined;
    doc_author?: string | undefined;
    doc_subject?: string | undefined;
}>>;
/**
 * Page range filter for chunk-level filtering
 */
export declare const PageRangeFilter: z.ZodOptional<z.ZodObject<{
    min_page: z.ZodOptional<z.ZodNumber>;
    max_page: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    min_page?: number | undefined;
    max_page?: number | undefined;
}, {
    min_page?: number | undefined;
    max_page?: number | undefined;
}>>;
/**
 * Search filters sub-object schema.
 * Groups all filter parameters into a single `filters` object to reduce
 * the top-level parameter count and improve schema clarity.
 */
export declare const SearchFilters: z.ZodDefault<z.ZodOptional<z.ZodObject<{
    document_filter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    metadata_filter: z.ZodOptional<z.ZodObject<{
        doc_title: z.ZodOptional<z.ZodString>;
        doc_author: z.ZodOptional<z.ZodString>;
        doc_subject: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        doc_title?: string | undefined;
        doc_author?: string | undefined;
        doc_subject?: string | undefined;
    }, {
        doc_title?: string | undefined;
        doc_author?: string | undefined;
        doc_subject?: string | undefined;
    }>>;
    cluster_id: z.ZodOptional<z.ZodString>;
    content_type_filter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    section_path_filter: z.ZodOptional<z.ZodString>;
    heading_filter: z.ZodOptional<z.ZodString>;
    page_range_filter: z.ZodOptional<z.ZodObject<{
        min_page: z.ZodOptional<z.ZodNumber>;
        max_page: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        min_page?: number | undefined;
        max_page?: number | undefined;
    }, {
        min_page?: number | undefined;
        max_page?: number | undefined;
    }>>;
    is_atomic_filter: z.ZodOptional<z.ZodBoolean>;
    heading_level_filter: z.ZodOptional<z.ZodObject<{
        min_level: z.ZodOptional<z.ZodNumber>;
        max_level: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        min_level?: number | undefined;
        max_level?: number | undefined;
    }, {
        min_level?: number | undefined;
        max_level?: number | undefined;
    }>>;
    min_page_count: z.ZodOptional<z.ZodNumber>;
    max_page_count: z.ZodOptional<z.ZodNumber>;
    table_columns_contain: z.ZodOptional<z.ZodString>;
    min_quality_score: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    document_filter?: string[] | undefined;
    metadata_filter?: {
        doc_title?: string | undefined;
        doc_author?: string | undefined;
        doc_subject?: string | undefined;
    } | undefined;
    cluster_id?: string | undefined;
    content_type_filter?: string[] | undefined;
    section_path_filter?: string | undefined;
    heading_filter?: string | undefined;
    page_range_filter?: {
        min_page?: number | undefined;
        max_page?: number | undefined;
    } | undefined;
    is_atomic_filter?: boolean | undefined;
    heading_level_filter?: {
        min_level?: number | undefined;
        max_level?: number | undefined;
    } | undefined;
    min_page_count?: number | undefined;
    max_page_count?: number | undefined;
    table_columns_contain?: string | undefined;
    min_quality_score?: number | undefined;
}, {
    document_filter?: string[] | undefined;
    metadata_filter?: {
        doc_title?: string | undefined;
        doc_author?: string | undefined;
        doc_subject?: string | undefined;
    } | undefined;
    cluster_id?: string | undefined;
    content_type_filter?: string[] | undefined;
    section_path_filter?: string | undefined;
    heading_filter?: string | undefined;
    page_range_filter?: {
        min_page?: number | undefined;
        max_page?: number | undefined;
    } | undefined;
    is_atomic_filter?: boolean | undefined;
    heading_level_filter?: {
        min_level?: number | undefined;
        max_level?: number | undefined;
    } | undefined;
    min_page_count?: number | undefined;
    max_page_count?: number | undefined;
    table_columns_contain?: string | undefined;
    min_quality_score?: number | undefined;
}>>>;
/**
 * Unified search schema - single schema for keyword, semantic, and hybrid search.
 * Mode parameter selects the search strategy. Defaults that are always-on are
 * hardcoded in the handler (quality_boost, expand_query, exclude_duplicate_chunks,
 * exclude headers/footers, include cluster context).
 *
 * Filter parameters are grouped under `filters` to reduce top-level parameter count.
 */
export declare const SearchUnifiedInput: z.ZodObject<{
    query: z.ZodString;
    mode: z.ZodDefault<z.ZodEnum<["keyword", "semantic", "hybrid"]>>;
    limit: z.ZodDefault<z.ZodNumber>;
    include_provenance: z.ZodDefault<z.ZodBoolean>;
    rerank: z.ZodDefault<z.ZodBoolean>;
    include_context_chunks: z.ZodDefault<z.ZodNumber>;
    group_by_document: z.ZodDefault<z.ZodBoolean>;
    filters: z.ZodDefault<z.ZodOptional<z.ZodObject<{
        document_filter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        metadata_filter: z.ZodOptional<z.ZodObject<{
            doc_title: z.ZodOptional<z.ZodString>;
            doc_author: z.ZodOptional<z.ZodString>;
            doc_subject: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            doc_title?: string | undefined;
            doc_author?: string | undefined;
            doc_subject?: string | undefined;
        }, {
            doc_title?: string | undefined;
            doc_author?: string | undefined;
            doc_subject?: string | undefined;
        }>>;
        cluster_id: z.ZodOptional<z.ZodString>;
        content_type_filter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        section_path_filter: z.ZodOptional<z.ZodString>;
        heading_filter: z.ZodOptional<z.ZodString>;
        page_range_filter: z.ZodOptional<z.ZodObject<{
            min_page: z.ZodOptional<z.ZodNumber>;
            max_page: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            min_page?: number | undefined;
            max_page?: number | undefined;
        }, {
            min_page?: number | undefined;
            max_page?: number | undefined;
        }>>;
        is_atomic_filter: z.ZodOptional<z.ZodBoolean>;
        heading_level_filter: z.ZodOptional<z.ZodObject<{
            min_level: z.ZodOptional<z.ZodNumber>;
            max_level: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            min_level?: number | undefined;
            max_level?: number | undefined;
        }, {
            min_level?: number | undefined;
            max_level?: number | undefined;
        }>>;
        min_page_count: z.ZodOptional<z.ZodNumber>;
        max_page_count: z.ZodOptional<z.ZodNumber>;
        table_columns_contain: z.ZodOptional<z.ZodString>;
        min_quality_score: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        document_filter?: string[] | undefined;
        metadata_filter?: {
            doc_title?: string | undefined;
            doc_author?: string | undefined;
            doc_subject?: string | undefined;
        } | undefined;
        cluster_id?: string | undefined;
        content_type_filter?: string[] | undefined;
        section_path_filter?: string | undefined;
        heading_filter?: string | undefined;
        page_range_filter?: {
            min_page?: number | undefined;
            max_page?: number | undefined;
        } | undefined;
        is_atomic_filter?: boolean | undefined;
        heading_level_filter?: {
            min_level?: number | undefined;
            max_level?: number | undefined;
        } | undefined;
        min_page_count?: number | undefined;
        max_page_count?: number | undefined;
        table_columns_contain?: string | undefined;
        min_quality_score?: number | undefined;
    }, {
        document_filter?: string[] | undefined;
        metadata_filter?: {
            doc_title?: string | undefined;
            doc_author?: string | undefined;
            doc_subject?: string | undefined;
        } | undefined;
        cluster_id?: string | undefined;
        content_type_filter?: string[] | undefined;
        section_path_filter?: string | undefined;
        heading_filter?: string | undefined;
        page_range_filter?: {
            min_page?: number | undefined;
            max_page?: number | undefined;
        } | undefined;
        is_atomic_filter?: boolean | undefined;
        heading_level_filter?: {
            min_level?: number | undefined;
            max_level?: number | undefined;
        } | undefined;
        min_page_count?: number | undefined;
        max_page_count?: number | undefined;
        table_columns_contain?: string | undefined;
        min_quality_score?: number | undefined;
    }>>>;
    phrase_search: z.ZodDefault<z.ZodBoolean>;
    include_highlight: z.ZodDefault<z.ZodBoolean>;
    similarity_threshold: z.ZodOptional<z.ZodNumber>;
    bm25_weight: z.ZodDefault<z.ZodNumber>;
    semantic_weight: z.ZodDefault<z.ZodNumber>;
    rrf_k: z.ZodDefault<z.ZodNumber>;
    auto_route: z.ZodDefault<z.ZodBoolean>;
    compact: z.ZodDefault<z.ZodBoolean>;
    include_provenance_summary: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    query: string;
    limit: number;
    mode: "keyword" | "semantic" | "hybrid";
    include_provenance: boolean;
    rerank: boolean;
    include_context_chunks: number;
    group_by_document: boolean;
    filters: {
        document_filter?: string[] | undefined;
        metadata_filter?: {
            doc_title?: string | undefined;
            doc_author?: string | undefined;
            doc_subject?: string | undefined;
        } | undefined;
        cluster_id?: string | undefined;
        content_type_filter?: string[] | undefined;
        section_path_filter?: string | undefined;
        heading_filter?: string | undefined;
        page_range_filter?: {
            min_page?: number | undefined;
            max_page?: number | undefined;
        } | undefined;
        is_atomic_filter?: boolean | undefined;
        heading_level_filter?: {
            min_level?: number | undefined;
            max_level?: number | undefined;
        } | undefined;
        min_page_count?: number | undefined;
        max_page_count?: number | undefined;
        table_columns_contain?: string | undefined;
        min_quality_score?: number | undefined;
    };
    phrase_search: boolean;
    include_highlight: boolean;
    bm25_weight: number;
    semantic_weight: number;
    rrf_k: number;
    auto_route: boolean;
    compact: boolean;
    include_provenance_summary: boolean;
    similarity_threshold?: number | undefined;
}, {
    query: string;
    limit?: number | undefined;
    mode?: "keyword" | "semantic" | "hybrid" | undefined;
    include_provenance?: boolean | undefined;
    rerank?: boolean | undefined;
    include_context_chunks?: number | undefined;
    group_by_document?: boolean | undefined;
    filters?: {
        document_filter?: string[] | undefined;
        metadata_filter?: {
            doc_title?: string | undefined;
            doc_author?: string | undefined;
            doc_subject?: string | undefined;
        } | undefined;
        cluster_id?: string | undefined;
        content_type_filter?: string[] | undefined;
        section_path_filter?: string | undefined;
        heading_filter?: string | undefined;
        page_range_filter?: {
            min_page?: number | undefined;
            max_page?: number | undefined;
        } | undefined;
        is_atomic_filter?: boolean | undefined;
        heading_level_filter?: {
            min_level?: number | undefined;
            max_level?: number | undefined;
        } | undefined;
        min_page_count?: number | undefined;
        max_page_count?: number | undefined;
        table_columns_contain?: string | undefined;
        min_quality_score?: number | undefined;
    } | undefined;
    phrase_search?: boolean | undefined;
    include_highlight?: boolean | undefined;
    similarity_threshold?: number | undefined;
    bm25_weight?: number | undefined;
    semantic_weight?: number | undefined;
    rrf_k?: number | undefined;
    auto_route?: boolean | undefined;
    compact?: boolean | undefined;
    include_provenance_summary?: boolean | undefined;
}>;
/**
 * Schema for FTS5 index management
 */
export declare const FTSManageInput: z.ZodObject<{
    action: z.ZodEnum<["rebuild", "status"]>;
}, "strip", z.ZodTypeAny, {
    action: "status" | "rebuild";
}, {
    action: "status" | "rebuild";
}>;
/**
 * Schema for getting a specific document
 */
export declare const DocumentGetInput: z.ZodObject<{
    document_id: z.ZodString;
    include_text: z.ZodDefault<z.ZodBoolean>;
    include_chunks: z.ZodDefault<z.ZodBoolean>;
    include_blocks: z.ZodDefault<z.ZodBoolean>;
    include_full_provenance: z.ZodDefault<z.ZodBoolean>;
    chunk_limit: z.ZodDefault<z.ZodNumber>;
    chunk_offset: z.ZodDefault<z.ZodNumber>;
    max_text_length: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    document_id: string;
    include_text: boolean;
    include_chunks: boolean;
    include_blocks: boolean;
    include_full_provenance: boolean;
    chunk_limit: number;
    chunk_offset: number;
    max_text_length: number;
}, {
    document_id: string;
    include_text?: boolean | undefined;
    include_chunks?: boolean | undefined;
    include_blocks?: boolean | undefined;
    include_full_provenance?: boolean | undefined;
    chunk_limit?: number | undefined;
    chunk_offset?: number | undefined;
    max_text_length?: number | undefined;
}>;
/**
 * Schema for deleting a document
 */
export declare const DocumentDeleteInput: z.ZodObject<{
    document_id: z.ZodString;
    confirm: z.ZodLiteral<true>;
}, "strip", z.ZodTypeAny, {
    document_id: string;
    confirm: true;
}, {
    document_id: string;
    confirm: true;
}>;
/**
 * Schema for retrying failed documents
 */
export declare const RetryFailedInput: z.ZodObject<{
    document_id: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    document_id?: string | undefined;
}, {
    document_id?: string | undefined;
}>;
/**
 * Schema for getting provenance information
 */
export declare const ProvenanceGetInput: z.ZodObject<{
    item_id: z.ZodString;
    item_type: z.ZodDefault<z.ZodEnum<["document", "ocr_result", "chunk", "embedding", "image", "comparison", "clustering", "form_fill", "extraction", "auto"]>>;
    include_descendants: z.ZodDefault<z.ZodBoolean>;
    descendants_limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    item_id: string;
    item_type: "chunk" | "extraction" | "image" | "document" | "ocr_result" | "embedding" | "comparison" | "clustering" | "form_fill" | "auto";
    include_descendants: boolean;
    descendants_limit: number;
}, {
    item_id: string;
    item_type?: "chunk" | "extraction" | "image" | "document" | "ocr_result" | "embedding" | "comparison" | "clustering" | "form_fill" | "auto" | undefined;
    include_descendants?: boolean | undefined;
    descendants_limit?: number | undefined;
}>;
/**
 * Schema for verifying provenance integrity
 */
export declare const ProvenanceVerifyInput: z.ZodObject<{
    item_id: z.ZodString;
    verify_content: z.ZodDefault<z.ZodBoolean>;
    verify_chain: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    item_id: string;
    verify_content: boolean;
    verify_chain: boolean;
}, {
    item_id: string;
    verify_content?: boolean | undefined;
    verify_chain?: boolean | undefined;
}>;
/**
 * Schema for exporting provenance data
 */
export declare const ProvenanceExportInput: z.ZodEffects<z.ZodObject<{
    scope: z.ZodEnum<["document", "database"]>;
    document_id: z.ZodOptional<z.ZodString>;
    format: z.ZodDefault<z.ZodEnum<["json", "w3c-prov", "csv"]>>;
    limit: z.ZodDefault<z.ZodNumber>;
    offset: z.ZodDefault<z.ZodNumber>;
    summary_only: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    format: "csv" | "json" | "w3c-prov";
    offset: number;
    scope: "document" | "database";
    summary_only: boolean;
    document_id?: string | undefined;
}, {
    scope: "document" | "database";
    limit?: number | undefined;
    document_id?: string | undefined;
    format?: "csv" | "json" | "w3c-prov" | undefined;
    offset?: number | undefined;
    summary_only?: boolean | undefined;
}>, {
    limit: number;
    format: "csv" | "json" | "w3c-prov";
    offset: number;
    scope: "document" | "database";
    summary_only: boolean;
    document_id?: string | undefined;
}, {
    scope: "document" | "database";
    limit?: number | undefined;
    document_id?: string | undefined;
    format?: "csv" | "json" | "w3c-prov" | undefined;
    offset?: number | undefined;
    summary_only?: boolean | undefined;
}>;
/**
 * Schema for getting configuration
 */
export declare const ConfigGetInput: z.ZodObject<{
    key: z.ZodOptional<z.ZodEnum<["ocr_default_mode", "ocr_max_concurrent", "embedding_batch_size", "embedding_device", "chunk_size", "chunk_overlap_percent", "max_chunk_size", "auto_cluster_enabled", "auto_cluster_threshold", "auto_cluster_algorithm"]>>;
}, "strip", z.ZodTypeAny, {
    key?: "ocr_default_mode" | "ocr_max_concurrent" | "embedding_batch_size" | "embedding_device" | "chunk_size" | "chunk_overlap_percent" | "max_chunk_size" | "auto_cluster_enabled" | "auto_cluster_threshold" | "auto_cluster_algorithm" | undefined;
}, {
    key?: "ocr_default_mode" | "ocr_max_concurrent" | "embedding_batch_size" | "embedding_device" | "chunk_size" | "chunk_overlap_percent" | "max_chunk_size" | "auto_cluster_enabled" | "auto_cluster_threshold" | "auto_cluster_algorithm" | undefined;
}>;
/**
 * Schema for setting configuration
 */
export declare const ConfigSetInput: z.ZodObject<{
    key: z.ZodEnum<["ocr_default_mode", "ocr_max_concurrent", "embedding_batch_size", "embedding_device", "chunk_size", "chunk_overlap_percent", "max_chunk_size", "auto_cluster_enabled", "auto_cluster_threshold", "auto_cluster_algorithm"]>;
    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
}, "strip", z.ZodTypeAny, {
    key: "ocr_default_mode" | "ocr_max_concurrent" | "embedding_batch_size" | "embedding_device" | "chunk_size" | "chunk_overlap_percent" | "max_chunk_size" | "auto_cluster_enabled" | "auto_cluster_threshold" | "auto_cluster_algorithm";
    value: string | number | boolean;
}, {
    key: "ocr_default_mode" | "ocr_max_concurrent" | "embedding_batch_size" | "embedding_device" | "chunk_size" | "chunk_overlap_percent" | "max_chunk_size" | "auto_cluster_enabled" | "auto_cluster_threshold" | "auto_cluster_algorithm";
    value: string | number | boolean;
}>;
/**
 * Sanitize a file path to prevent directory traversal attacks.
 *
 * SEC-002 ENFORCEMENT: Paths are ALWAYS validated against allowed directories.
 * When no allowedBaseDirs are provided, a default set is used that covers
 * the storage path, home directory, /tmp, and the current working directory.
 *
 * - Rejects null bytes
 * - Auto-translates Windows-style paths (C:\...) to /host/... on Linux (Docker support)
 * - Resolves the path fully via path.resolve() to eliminate '..' segments
 * - Verifies the resolved path starts with one of the allowed base directories
 *
 * @param filePath - The file path to sanitize
 * @param allowedBaseDirs - Optional array of allowed base directories. When omitted,
 *   defaults to [storagePath, homedir, /tmp, cwd] per SEC-002.
 * @returns The resolved, safe path
 * @throws ValidationError if the path contains null bytes or escapes allowed directories
 */
export declare function sanitizePath(filePath: string, allowedBaseDirs?: string[]): string;
/**
 * Validate that a sanitized path is writable.
 * In Docker, /host is mounted read-only. Write operations must target /export or /data.
 * Call AFTER sanitizePath() — this checks the resolved path for write-safety.
 *
 * @param resolvedPath - The path returned by sanitizePath()
 * @returns The path unchanged if writable
 * @throws ValidationError if the path targets a read-only mount
 */
export declare function ensureWritablePath(resolvedPath: string): string;
/**
 * Escape special characters for safe use in SQL LIKE clauses.
 * Escapes '%', '_', and '\' characters.
 *
 * @param pattern - The raw string to escape
 * @returns The escaped string safe for LIKE clause usage
 */
export declare function escapeLikePattern(pattern: string): string;
//# sourceMappingURL=validation.d.ts.map