ocr-provenance-mcp 1.0.0

package/dist/utils/validation.d.ts

@@ -0,0 +1,697 @@
+/**
+ * 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;
+/**
+ * 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<["datalab_default_mode", "datalab_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.ZodString>;
+    storage_path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+    storage_path?: string | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    storage_path?: string | undefined;
+}>;
+/**
+ * Schema for listing databases
+ */
+export declare const DatabaseListInput: z.ZodObject<{
+    include_stats: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    include_stats: boolean;
+}, {
+    include_stats?: boolean | undefined;
+}>;
+/**
+ * Schema for selecting a database
+ */
+export declare const DatabaseSelectInput: z.ZodObject<{
+    database_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    database_name: string;
+}, {
+    database_name: string;
+}>;
+/**
+ * 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">>>;
+}, "strip", z.ZodTypeAny, {
+    recursive: boolean;
+    directory_path: string;
+    file_types: string[];
+}, {
+    directory_path: string;
+    recursive?: boolean | undefined;
+    file_types?: string[] | 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.ZodDefault<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;
+    similarity_threshold: number;
+    bm25_weight: number;
+    semantic_weight: number;
+    rrf_k: number;
+    auto_route: boolean;
+    compact: boolean;
+    include_provenance_summary: boolean;
+}, {
+    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 listing documents
+ */
+export declare const DocumentListInput: z.ZodObject<{
+    status_filter: z.ZodOptional<z.ZodEnum<["pending", "processing", "complete", "failed"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    created_after: z.ZodOptional<z.ZodString>;
+    created_before: z.ZodOptional<z.ZodString>;
+    file_type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    file_type?: string | undefined;
+    created_after?: string | undefined;
+    created_before?: string | undefined;
+    status_filter?: "pending" | "processing" | "complete" | "failed" | undefined;
+}, {
+    limit?: number | undefined;
+    file_type?: string | undefined;
+    offset?: number | undefined;
+    created_after?: string | undefined;
+    created_before?: string | undefined;
+    status_filter?: "pending" | "processing" | "complete" | "failed" | undefined;
+}>;
+/**
+ * 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>;
+}, "strip", z.ZodTypeAny, {
+    document_id: string;
+    include_text: boolean;
+    include_chunks: boolean;
+    include_blocks: boolean;
+    include_full_provenance: boolean;
+}, {
+    document_id: string;
+    include_text?: boolean | undefined;
+    include_chunks?: boolean | undefined;
+    include_blocks?: boolean | undefined;
+    include_full_provenance?: boolean | 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"]>>;
+}, "strip", z.ZodTypeAny, {
+    item_id: string;
+    item_type: "chunk" | "extraction" | "image" | "document" | "ocr_result" | "embedding" | "comparison" | "clustering" | "form_fill" | "auto";
+}, {
+    item_id: string;
+    item_type?: "chunk" | "extraction" | "image" | "document" | "ocr_result" | "embedding" | "comparison" | "clustering" | "form_fill" | "auto" | 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"]>>;
+}, "strip", z.ZodTypeAny, {
+    format: "csv" | "json" | "w3c-prov";
+    scope: "document" | "database";
+    document_id?: string | undefined;
+}, {
+    scope: "document" | "database";
+    document_id?: string | undefined;
+    format?: "csv" | "json" | "w3c-prov" | undefined;
+}>, {
+    format: "csv" | "json" | "w3c-prov";
+    scope: "document" | "database";
+    document_id?: string | undefined;
+}, {
+    scope: "document" | "database";
+    document_id?: string | undefined;
+    format?: "csv" | "json" | "w3c-prov" | undefined;
+}>;
+/**
+ * Schema for getting configuration
+ */
+export declare const ConfigGetInput: z.ZodObject<{
+    key: z.ZodOptional<z.ZodEnum<["datalab_default_mode", "datalab_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?: "datalab_default_mode" | "datalab_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?: "datalab_default_mode" | "datalab_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<["datalab_default_mode", "datalab_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, {
+    value: string | number | boolean;
+    key: "datalab_default_mode" | "datalab_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: "datalab_default_mode" | "datalab_max_concurrent" | "embedding_batch_size" | "embedding_device" | "chunk_size" | "chunk_overlap_percent" | "max_chunk_size" | "auto_cluster_enabled" | "auto_cluster_threshold" | "auto_cluster_algorithm";
+}>;
+/**
+ * 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
+ * - 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;
+/**
+ * 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