import {z} from 'zod'

export type JsonValue = unknown;

export type QaFileRequest = {path: string, query: string, include_citations?: boolean | undefined, component?: (string | null) | undefined, output_schema?: ({[key: string]: JsonValue} | null) | undefined};

export type CreateApiV1WorkspacesWorkspaceIdToolsQaFileArgs = {workspace_id: string, prefer?: (string | null) | undefined, 'Idempotency-Key'?: (string | null) | undefined, body: QaFileRequest};

export type CreateApiV1WorkspacesWorkspaceIdToolsQaFileOptions = {baseUrl: string, APIKeyHeader?: string | undefined, fetch?: typeof fetch | undefined};

export const jsonValue = z.unknown();

export const textRange = z.object({kind: z.literal("text_range").optional(), page: z.number().int().nullable().optional(), pages: z.array(z.number().int()).optional(), char_start: z.number().int(), char_end: z.number().int()});

export const visualRegion = z.object({kind: z.literal("visual_region").optional(), page: z.number().int(), bbox: z.array(z.unknown())});

export const spreadsheetRange = z.object({kind: z.literal("spreadsheet_range").optional(), sheet: z.string(), a1_range: z.string()});

export const jsonlRecord = z.object({kind: z.literal("jsonl_record").optional(), row_offset: z.number().int(), column: z.string().nullable().optional()});

export const jsonPointer = z.object({kind: z.literal("json_pointer").optional(), pointer: z.string()});

export const audioRange = z.object({kind: z.literal("audio_range").optional(), start_ms: z.number().int(), end_ms: z.number().int()});

export const rowRange = z.object({kind: z.literal("row_range").optional(), start_row: z.number().int().gte(0), end_row: z.number().int().gte(0), column: z.string().nullable().optional()});

export const evidence = z.object({file_id: z.string(), path: z.string(), locator: z.union([textRange, visualRegion, spreadsheetRange, jsonlRecord, jsonPointer, audioRange, rowRange]).nullable().optional(), page: z.number().int().nullable().optional(), relevance_score: z.number(), snippet: z.string(), why: z.string(), component: z.string().nullable().optional(), sql_table: z.string().nullable().optional(), line_start: z.number().int().nullable().optional(), line_end: z.number().int().nullable().optional()});

export const confidenceLevel = z.enum(["certain", "very_high", "high", "medium", "low", "speculative"]);

export const unavailableTable = z.object({path: z.string(), error: z.string(), error_kind: z.enum(["conversion_rejected", "conversion_failed", "profile_rejected", "profile_failed"]).nullable().optional()});

export const qaFileResponse = z.object({job_id: z.string().nullable().optional(), answer: z.string(), structured_answer: jsonValue.nullable().optional(), citations: z.array(evidence), engine: z.enum(["recursive_llm", "vision", "agent"]), confidence: confidenceLevel.nullable().optional(), unavailable: z.array(unavailableTable).optional(), timed_out: z.boolean().optional()});

export const jobKind = z.enum(["parse", "split", "classify", "categorize", "extract", "ground", "ingestion", "reconciliation", "kg_build", "file_upload", "file_replace", "upload_session_complete", "file_delete", "files_delete", "workspace_delete", "intelligent_search", "folder_metadata", "file_metadata", "read_file", "hybrid_search", "grep", "run_sql", "locate", "qa_file", "qa_tables", "filtered_search", "je_testing", "je_testing_v2", "deep_search_v2", "automatic_agent", "ledger_understanding", "ledger_understanding_reset", "ledger_parse_exhibits", "tenant_purge", "storage_connection_validate"]);

export const ndiServiceAppPlatformApiContractsJobStatus = z.enum(["queued", "running", "succeeded", "failed", "cancelled"]);

export const uploadSource = z.object({type: z.literal("upload").optional(), upload_id: z.string()});

export const urlSource = z.object({type: z.literal("url").optional(), url: z.string().max(2048), file_name: z.string().max(512)});

export const workspaceFileSource = z.object({type: z.literal("workspace_file").optional(), workspace_id: z.string(), file_id: z.string()});

export const parseResultSource = z.object({type: z.literal("parse_result").optional(), job_id: z.string()});

export const workspaceQueryScope = z.object({type: z.literal("workspace").optional()});

export const fileQueryScope = z.object({type: z.literal("file").optional(), path: z.string().min(1).max(1024)});

export const pathPrefixQueryScope = z.object({type: z.literal("path_prefix").optional(), prefix: z.string().min(1).max(1024)});

export const filesQueryScope = z.object({type: z.literal("files").optional(), count: z.number().int().gte(2)});

export const knowledgeGraphBuildProgress = z.object({phase_index: z.number().int(), phase_count: z.number().int(), countable: z.boolean(), documents: z.number().int().nullable().optional(), mentions: z.number().int().nullable().optional(), step: z.string().nullable().optional(), step_done: z.number().int().nullable().optional(), step_total: z.number().int().nullable().optional()});

export const automaticLlmRouter = z.object({kind: z.literal("llm").optional()});

export const automaticNaceDmRouter = z.object({kind: z.literal("nacedm").optional(), p_agent: z.number().gte(0).lte(1).nullable(), decision_point: z.number().gte(0).lte(1)});

export const automaticRequestedRouter = z.object({kind: z.literal("requested").optional()});

export const automaticSearchRouting = z.object({selected: z.enum(["fact", "agent", "deep", "filtered"]), final: z.enum(["fact", "agent", "deep", "filtered"]), reason: z.string(), router_model: z.string(), router: z.discriminatedUnion("kind", [automaticLlmRouter, automaticNaceDmRouter, automaticRequestedRouter]).optional(), router_wall_ms: z.number().int().nullable().optional(), fact_wall_ms: z.number().int().nullable().optional(), delegated_wall_ms: z.number().int().nullable().optional()});

export const jobProgress = z.object({units_total: z.number().int().nullable().optional(), units_done: z.number().int().optional(), items_total: z.number().int().nullable().optional(), items_done: z.number().int().optional(), items_failed: z.number().int().optional(), stage: z.string().nullable().optional(), knowledge_graph: knowledgeGraphBuildProgress.nullable().optional(), routing: automaticSearchRouting.nullable().optional()});

export const storageConnectionValidationResult = z.object({result_type: z.literal("storage_connection_validate").optional(), connection_id: z.string(), credential_generation: z.number().int()});

export const categoryCount = z.object({name: z.string(), count: z.number().int()});

export const subdirectorySummary = z.object({name: z.string(), overall_files: z.number().int(), top_categories: z.array(categoryCount).optional(), failed_files: z.number().int().nullable().optional()});

export const ingestionStatus = z.enum(["discovered", "queued", "ingesting", "ingested", "stale", "expired", "failed", "not_required"]);

export const folderFileEntry = z.object({path: z.string(), ingestion_status: ingestionStatus, size_bytes: z.number().int(), category: z.string().nullable().optional(), kind: z.string().nullable().optional(), uploaded_at: z.string().nullable().optional()});

export const coverage = z.object({restricted_candidates: z.number().int().optional(), labels_required: z.array(z.string()).optional(), request_access_hint: z.string().nullable().optional()});

export const folderMetadataResponse = z.object({directory: z.string(), overall_files: z.number().int(), categories: z.array(categoryCount), subdirectories: z.array(subdirectorySummary), ingestion_summary: z.record(z.string(), z.number().int()), files_truncated: z.boolean(), file_entries: z.array(folderFileEntry), hint: z.string().nullable().optional(), coverage: coverage, job_id: z.string().nullable().optional()});

export const folderMetadataResult = z.object({result_type: z.literal("folder_metadata").optional(), output: folderMetadataResponse});

export const fileKeywordDescription = z.record(z.string(), z.string().nullable());

export const fileComponentInfo = z.object({kind: z.enum(["section", "tab", "image", "raw"]), name: z.string(), summary: z.string().optional(), categories: z.array(z.string()).optional(), key_terms: z.array(fileKeywordDescription).optional(), page_start: z.number().int().nullable().optional(), page_end: z.number().int().nullable().optional(), row_count: z.number().int().nullable().optional(), column_count: z.number().int().nullable().optional(), readable: z.boolean(), queryable: z.boolean(), error: z.string().nullable().optional()});

export const mediaComponentInfo = z.object({kind: z.literal("media").optional(), modality: z.enum(["audio", "video"]), duration_ms: z.number().int(), speaker_count: z.number().int(), summary: z.string().optional()});

export const fileFigureInfo = z.object({name: z.string(), page: z.number().int(), description: z.string().nullable().optional(), text: z.string().optional()});

export const fileMetadataToolResponse = z.object({path: z.string(), file_id: z.string(), kind: z.string().nullable().optional(), ingestion_status: ingestionStatus, ingestion_error: z.string().nullable().optional(), size_bytes: z.number().int(), category: z.string().nullable().optional(), page_count: z.number().int().nullable().optional(), tab_count: z.number().int().nullable().optional(), summary: z.string().optional(), components: z.array(z.discriminatedUnion("kind", [fileComponentInfo, mediaComponentInfo])).optional(), figures: z.array(fileFigureInfo).optional(), job_id: z.string().nullable().optional()});

export const fileMetadataResult = z.object({result_type: z.literal("file_metadata").optional(), output: fileMetadataToolResponse});

export const grepTable = z.object({first_line: z.number().int(), last_line: z.number().int(), title: z.string().nullable(), header: z.string(), rows: z.number().int().nullable().optional()});

export const readFileResponse = z.object({path: z.string(), file_id: z.string(), content: z.string(), pages_returned: z.array(z.number().int()), truncated: z.boolean(), components_returned: z.array(z.string()), components_omitted: z.array(z.string()), sql_tables: z.array(z.string()).optional(), line_start: z.number().int().nullable().optional(), line_end: z.number().int().nullable().optional(), line_count: z.number().int().nullable().optional(), table: grepTable.nullable().optional(), job_id: z.string().nullable().optional()});

export const readFileResult = z.object({result_type: z.literal("read_file").optional(), output: readFileResponse});

export const searchResponse = z.object({hits: z.array(evidence), candidates_seen: z.number().int(), truncated: z.boolean(), coverage: coverage, job_id: z.string().nullable().optional()});

export const hybridSearchResult = z.object({result_type: z.literal("hybrid_search").optional(), output: searchResponse});

export const grepMatch = z.object({file_id: z.string(), path: z.string(), component: z.string().nullable(), kind: z.enum(["section", "tab", "media", "image", "raw"]), line: z.number().int().nullable(), page: z.number().int().nullable(), text: z.string(), sql_table: z.string().nullable().optional(), table: grepTable.nullable().optional(), context_before: z.array(z.string()).optional(), context_after: z.array(z.string()).optional()});

export const grepResponse = z.object({matches: z.array(grepMatch), files_matched: z.number().int(), files_scanned: z.number().int(), files_unscanned: z.number().int(), truncated: z.boolean(), mode: z.enum(["scan", "index"]), notes: z.array(z.string()).optional(), near_misses: z.array(grepMatch).optional(), job_id: z.string().nullable().optional()});

export const grepResult = z.object({result_type: z.literal("grep").optional(), output: grepResponse});

export const queryTableColumn = z.object({name: z.string(), data_type: z.string()});

export const queryTablePreview = z.object({path: z.string().nullable().optional(), handle: z.string(), row_count: z.number().int(), columns: z.array(queryTableColumn).optional(), rows: z.array(z.record(z.string(), z.string())).optional(), preview_truncated: z.boolean().optional()});

export const queryTableResultFile = z.object({file_id: z.string(), handle: z.string(), path: z.string(), file_name: z.string(), format: z.literal("parquet"), row_count: z.number().int(), download_url: z.string(), preview_url: z.string(), download_url_expires_at: z.string()});

export const tableQueryColumn = z.object({name: z.string(), data_type: z.string()});

export const sheetQueryRegion = z.object({kind: z.literal("sheet").optional(), source_path: z.string(), sheet_name: z.string().nullable().optional(), a1_range: z.string(), matched_rows: z.number().int().optional(), bounding: z.boolean().optional(), basis: z.enum(["verified", "inputs", "provenance"]).optional(), scan_index: z.number().int().nullable().optional(), scan_label: z.string().nullable().optional()});

export const artifactRowRun = z.object({start: z.number().int(), end: z.number().int()});

export const rowRangeQueryRegion = z.object({kind: z.literal("row_range").optional(), region_id: z.string().nullable().optional(), source_path: z.string(), start_row: z.number().int(), end_row: z.number().int(), columns: z.array(z.string()).optional(), filter_columns: z.array(z.string()).optional(), read_columns: z.array(z.string()).optional(), matched_rows: z.number().int().optional(), bounding: z.boolean().optional(), derivative_path: z.string().nullable().optional(), runs: z.array(artifactRowRun).optional(), runs_truncated: z.boolean().optional(), runs_replayable: z.boolean().optional(), basis: z.enum(["verified", "inputs", "provenance"]).optional(), scan_index: z.number().int().nullable().optional(), scan_label: z.string().nullable().optional()});

export const tableQueryGrounding = z.object({sql: z.string(), supports_answer: z.boolean().optional(), result_id: z.string().nullable().optional(), source_paths: z.array(z.string()).optional(), row_count: z.number().int().optional(), columns: z.array(tableQueryColumn).optional(), rows: z.array(z.record(z.string(), z.string())).optional(), preview_truncated: z.boolean().optional(), verified: z.boolean().optional(), regions: z.array(z.discriminatedUnion("kind", [sheetQueryRegion, rowRangeQueryRegion])).optional(), grounding_status: z.enum(["exact", "unavailable", "zero_result"]).nullable().optional(), grounding_reason: z.string().nullable().optional()});

export const queryTableCitation = z.object({result_file: queryTableResultFile, source_paths: z.array(z.string()), sql: z.string(), grounding: tableQueryGrounding.nullable().optional()});

export const runSqlResponse = z.object({sql: z.string(), duplicate: z.boolean().optional(), result: queryTablePreview, source_paths: z.array(z.string()).optional(), result_citation: queryTableCitation.nullable().optional(), result_materialization_error: z.string().nullable().optional(), job_id: z.string().nullable().optional()});

export const runSqlResult = z.object({result_type: z.literal("run_sql").optional(), output: runSqlResponse});

export const locatedPiece = z.object({path: z.string(), component: z.string().nullable().optional(), paged: z.boolean(), number: z.number().int(), line_start: z.number().int().nullable().optional(), line_end: z.number().int().nullable().optional(), score: z.number(), head: z.string()});

export const locatedTableRef = z.object({sql_table: z.string(), path: z.string(), tab: z.string().nullable().optional(), score: z.number(), columns: z.array(z.string()), relevant_columns: z.array(z.string())});

export const locatedMember = z.object({path: z.string(), score: z.number()});

export const locateResponse = z.object({text: z.string(), pages: z.array(locatedPiece), tables: z.array(locatedTableRef), population: z.array(locatedMember), population_unrated: z.number().int().optional(), job_id: z.string().nullable().optional()});

export const locateResult = z.object({result_type: z.literal("locate").optional(), output: locateResponse});

export const sheetRange = z.object({kind: z.literal("sheet_range").optional(), sheet: z.string(), a1_range: z.string()});

export const textSpan = z.object({kind: z.literal("text_span").optional(), page: z.number().int().gte(1).nullable().optional(), char_start: z.number().int().gte(0), char_end: z.number().int().gte(0)});

export const pageRegion = z.object({kind: z.literal("page_region").optional(), page: z.number().int().gte(1), polygons: z.array(z.array(z.array(z.unknown()))).optional()});

export const tableRowRange = z.object({start: z.number().int().gte(0), end: z.number().int().gte(0)});

export const tableRegion = z.object({kind: z.literal("table_region").optional(), source_file_name: z.string(), row_ranges: z.array(tableRowRange).optional(), columns: z.array(z.string()).optional(), sql: z.string(), matched_rows: z.number().int().gte(0).optional(), exact: z.boolean()});

export const parsedBlock = z.object({id: z.string(), type: z.string(), content: z.string(), sheet_name: z.string().nullable().optional(), source_id: z.string().nullable().optional(), source_name: z.string().nullable().optional(), image_anchor: sheetRange.nullable().optional(), markdown_span: textSpan.nullable().optional(), table_row_offset: z.number().int().gte(0).optional(), location: z.union([pageRegion, sheetRange, textSpan, rowRange, tableRegion, jsonPointer]).nullable().optional(), confidence: z.number().gte(0).lte(1).nullable().optional(), image_url: z.string().nullable().optional()});

export const parseChunk = z.object({id: z.string(), content: z.string(), location: z.union([pageRegion, sheetRange, textSpan, rowRange, tableRegion, jsonPointer]).nullable().optional()});

export const ocrBoundingBox = z.object({left: z.number(), top: z.number(), width: z.number(), height: z.number(), page: z.number().int(), original_page: z.number().int()});

export const ocrElement = z.object({text: z.string(), bbox: ocrBoundingBox, confidence: z.number(), chunk_index: z.number().int().nullable().optional(), rotation: z.number().int().optional()});

export const parseOcrData = z.object({words: z.array(ocrElement).optional(), lines: z.array(ocrElement).optional()});

export const parseSpreadsheetSheet = z.object({sheet_name: z.string(), cell_map_url: z.string().nullable().optional(), content_url: z.string().nullable().optional(), rows_url: z.string().nullable().optional(), markdown_deferred: z.boolean().optional(), source_sha256: z.string().nullable().optional(), row_count: z.number().int().gte(0).nullable().optional(), column_count: z.number().int().gte(0).nullable().optional()});

export const parseSpreadsheet = z.object({sheets: z.array(parseSpreadsheetSheet).optional()});

export const parseDocument = z.object({page_count: z.number().int(), markdown: z.string().nullable().optional(), content_url: z.string().nullable().optional(), text: z.string().nullable().optional(), blocks: z.array(parsedBlock).nullable().optional(), has_signature: z.boolean().nullable().optional(), chunks: z.array(parseChunk).optional(), ocr: parseOcrData.nullable().optional(), spreadsheet: parseSpreadsheet.nullable().optional()});

export const mediaSpeaker = z.object({id: z.string(), label: z.string().nullable().optional()});

export const mediaFrameRef = z.object({timestamp_ms: z.number().int(), path: z.string()});

export const mediaSpeechSegment = z.object({kind: z.literal("speech").optional(), start_ms: z.number().int(), end_ms: z.number().int(), speaker: z.string().nullable(), transcript: z.string(), frames: z.array(mediaFrameRef).optional()});

export const mediaSilenceSegment = z.object({kind: z.literal("silence").optional(), start_ms: z.number().int(), end_ms: z.number().int(), speaker: z.unknown(), transcript: z.literal("").optional(), frames: z.array(mediaFrameRef).optional()});

export const mediaTimeline = z.object({schema_version: z.number().int(), modality: z.enum(["audio", "video"]), duration_ms: z.number().int(), speakers: z.array(mediaSpeaker).optional(), segments: z.array(z.discriminatedUnion("kind", [mediaSpeechSegment, mediaSilenceSegment])).optional(), peaks: z.array(z.number()).optional()});

export const classificationGapFillDisclosure = z.object({code: z.literal("classification_gap_fill"), filled_pages: z.array(z.number().int().gte(1)), fallback_label: z.string()});

export const classificationUnreadPagesDisclosure = z.object({code: z.literal("classification_unread_pages"), unread_pages: z.array(z.number().int().gte(1))});

export const extractionNullOnSuccessDisclosure = z.object({code: z.literal("extraction_null_on_success"), field_paths: z.array(z.string())});

export const parseEngine = z.enum(["native_ocr", "document_ocr", "layout_ocr"]);

export const parseVendorProvenanceDisclosure = z.object({code: z.literal("parse_vendor_provenance"), engine: parseEngine, fallback_depth: z.number().int().gte(0)});

export const parseFidelityDisclosure = z.object({code: z.literal("parse_fidelity"), mode: z.enum(["reduced_resolution", "reduced_layout"]), pages: z.array(z.number().int().gte(1))});

export const truncationTarget = z.enum(["classification_input", "document_content", "spreadsheet_region", "extraction_array"]);

export const truncationUnit = z.enum(["characters", "tokens", "rows", "columns", "cells", "items"]);

export const contentTruncatedDisclosure = z.object({code: z.literal("content_truncated"), target: truncationTarget, unit: truncationUnit, original_size: z.number().int().gte(1), retained_size: z.number().int().gte(0)});

export const sourceIncompleteDisclosure = z.object({code: z.literal("source_incomplete"), received_bytes: z.number().int().gte(1)});

export const ndiServiceAppPlatformApiResultsParseResult = z.object({result_type: z.literal("parse").optional(), file_name: z.string(), lane: z.string(), document: parseDocument, ocr_applied: z.boolean(), units: z.number().int(), converted_pdf_url: z.string().nullable().optional(), transcript_url: z.string().nullable().optional(), transcript: mediaTimeline.nullable().optional(), warnings: z.array(z.string()).optional(), disclosures: z.array(z.discriminatedUnion("code", [classificationGapFillDisclosure, classificationUnreadPagesDisclosure, extractionNullOnSuccessDisclosure, parseVendorProvenanceDisclosure, parseFidelityDisclosure, contentTruncatedDisclosure, sourceIncompleteDisclosure])).optional()});

export const splitSegmentCategory = z.object({id: z.string(), label: z.string(), description: z.string().optional(), parent_id: z.string().nullable().optional(), subcategory_id: z.string().nullable().optional()});

export const splitInstance = z.object({key: z.string(), value: z.string().nullable().optional()});

export const splitConfidence = z.object({band: z.enum(["unavailable", "low", "medium", "high"]).optional(), score: z.number().nullable().optional()});

export const splitArtifact = z.object({url: z.string()});

export const splitSegment = z.object({id: z.string(), sequence: z.number().int().gte(0), status: z.enum(["matched", "unclassified"]), class: splitSegmentCategory.nullable().optional(), classes: z.array(splitSegmentCategory).nullable().optional(), start_page: z.number().int().gte(1).nullable().optional(), end_page: z.number().int().gte(1).nullable().optional(), sheet_name: z.string().nullable().optional(), json_pointer: z.string().nullable().optional(), instance: splitInstance.nullable().optional(), classification_confidence: splitConfidence.optional(), boundary_confidence: splitConfidence.optional(), content: z.string().nullable().optional(), artifacts: z.array(splitArtifact).optional(), warnings: z.array(z.string()).optional()});

export const splitResult = z.object({result_type: z.literal("split").optional(), file_name: z.string(), lane: z.string(), page_count: z.number().int(), segments: z.array(splitSegment), units: z.number().int(), warnings: z.array(z.string()).optional()});

export const classifyPageRange = z.object({start: z.number().int().gte(1), end: z.number().int().gte(1)});

export const classifyLabel = z.object({class_id: z.string(), subclass_id: z.string().nullable().optional(), label: z.string(), rank: z.number().int().gte(1), reason: z.string().nullable().optional(), confidence: z.number().nullable().optional()});

export const classifyUnit = z.object({granularity: z.enum(["document", "page"]).optional(), page_range: classifyPageRange.nullable().optional(), unknown: z.boolean(), labels: z.array(classifyLabel)});

export const classifyResult = z.object({result_type: z.literal("classify").optional(), reason_status: z.enum(["pending", "complete", "failed", "not_requested"]).optional(), labels_at: z.string().nullable().optional(), units: z.array(classifyUnit), unknown_units: z.number().int().optional(), pages_read_fraction: z.number().gte(0).lte(1).optional(), warnings: z.array(z.string()).optional(), disclosures: z.array(z.discriminatedUnion("code", [classificationGapFillDisclosure, classificationUnreadPagesDisclosure, extractionNullOnSuccessDisclosure, parseVendorProvenanceDisclosure, parseFidelityDisclosure, contentTruncatedDisclosure, sourceIncompleteDisclosure])).optional()});

export const scoredCategory = z.object({category: z.string(), confidence: z.number()});

export const categoryAssignment = z.object({source_index: z.number().int(), file_name: z.string(), category: z.string().nullable().optional(), confidence: z.number(), evidence: evidence.nullable().optional(), alternatives: z.array(scoredCategory).optional()});

export const ndiServiceAppPlatformApiResultsCategorizeResult = z.object({result_type: z.literal("categorize").optional(), assignments: z.array(categoryAssignment), units: z.number().int(), warnings: z.array(z.string()).optional()});

export const wordAnchor = z.object({part: z.string(), paragraph_index: z.number().int().gte(0), char_start: z.number().int().gte(0), char_end: z.number().int().gt(0)});

export const citation = z.object({location: z.discriminatedUnion("kind", [pageRegion, sheetRange, textSpan, rowRange, tableRegion, jsonPointer]), word_anchor: wordAnchor.nullable().optional(), source_text: z.string().nullable().optional()});

export const extractedField = z.object({path: z.string(), value: z.union([z.string(), z.number().int(), z.number(), z.boolean()]).nullable().optional(), status: z.enum(["found", "not_found", "ambiguous"]), confidence: z.number().nullable().optional(), citations: z.array(citation).optional()});

export const ndiServiceAppPlatformApiResultsExtractResult = z.object({result_type: z.literal("extract").optional(), enrichment_status: z.enum(["pending", "complete", "degraded"]).optional(), data: z.record(z.string(), z.unknown()).optional(), fields: z.array(extractedField), schema_id: z.string().nullable().optional(), schema_version: z.number().int().gte(1).nullable().optional(), converted_pdf_url: z.string().nullable().optional(), units: z.number().int(), warnings: z.array(z.string()).optional(), disclosures: z.array(z.discriminatedUnion("code", [classificationGapFillDisclosure, classificationUnreadPagesDisclosure, extractionNullOnSuccessDisclosure, parseVendorProvenanceDisclosure, parseFidelityDisclosure, contentTruncatedDisclosure, sourceIncompleteDisclosure])).optional(), unrefined_field_paths: z.array(z.string()).optional()});

export const groundMatch = z.object({word_anchor: wordAnchor.nullable().optional(), rank: z.number().int().gte(1), matched_text: z.string(), match_method: z.enum(["exact", "normalized", "semantic"]), confidence: z.number().gte(0).lte(1).nullable().optional(), location: z.union([z.union([pageRegion, sheetRange, textSpan, rowRange, tableRegion, jsonPointer]), z.union([textRange, visualRegion, spreadsheetRange, jsonlRecord, jsonPointer, audioRange, rowRange])]), cropped_image_url: z.string().nullable().optional()});

export const groundTargetResult = z.object({id: z.string(), status: z.enum(["found", "not_found", "failed"]), matches: z.array(groundMatch).optional(), error: z.string().nullable().optional()});

export const ndiServiceAppPlatformApiResultsGroundResult = z.object({result_type: z.literal("ground").optional(), targets: z.array(groundTargetResult), units: z.number().int(), transcript_url: z.string().nullable().optional(), converted_pdf_url: z.string().nullable().optional(), warnings: z.array(z.string()).optional()});

export const errorCode = z.enum(["storage_connection_not_found", "storage_connection_in_use", "storage_limit_exceeded", "storage_conflict", "storage_auth_required", "storage_unavailable", "scan_required", "scan_rejected", "scan_unavailable", "invalid_request", "unsupported_file_type", "file_too_large", "invalid_schema", "invalid_sql", "invalid_path_prefix", "command_not_permitted", "batch_too_large", "domain_validation_failed", "default_label_required", "wait_required_for_zero_retention", "ledger_decision_invalid", "tenant_required", "partner_required", "workspace_not_found", "file_not_found", "job_not_found", "upload_not_found", "node_not_found", "schema_not_found", "domain_not_found", "session_not_found", "access_label_not_found", "ledger_understanding_not_found", "ledger_table_not_found", "tenant_not_found", "path_conflict", "schema_version_conflict", "access_label_name_taken", "workspace_name_taken", "access_label_in_use", "upload_expired", "file_not_ingested", "workspace_deleting", "workspace_not_deletable", "ingestion_in_progress", "job_not_cancellable", "confirmation_required", "domain_not_published", "domain_in_use", "reserved_domain_slug", "kg_not_built", "kg_build_in_progress", "ledger_understanding_in_progress", "ledger_understanding_version_outdated", "session_busy", "tenant_limit_reached", "range_not_satisfiable", "result_expired", "access_denied", "tenant_disabled", "access_backstop_violation", "access_mode_not_implemented", "rate_limited", "concurrency_limit_reached", "quota_exceeded", "corrupt_file", "zero_byte_file", "encrypted_file", "csv_dialect_ambiguous", "csv_parse_failed", "parse_failed", "ocr_failed", "conversion_failed", "sheetless_workbook", "unplayable_media", "unclassified_pages", "job_cancelled", "job_timeout", "upstream_unavailable", "internal_error", "unauthorized", "not_implemented"]);

export const error = z.object({code: errorCode, message: z.string(), detail: z.record(z.string(), z.unknown()).nullable().optional(), retryable: z.boolean(), request_id: z.string().nullable().optional()});

export const ingestedFileOutcome = z.object({file_id: z.string(), path: z.string(), status: z.enum(["ingested", "skipped_unchanged", "skipped_empty", "failed"]), lane: z.string().nullable().optional(), units: z.number().int().optional(), error: error.nullable().optional()});

export const ingestionResult = z.object({result_type: z.literal("ingestion").optional(), outcomes: z.array(ingestedFileOutcome), files_ingested: z.number().int(), files_skipped: z.number().int(), files_empty: z.number().int().optional(), files_failed: z.number().int(), units_total: z.number().int(), kg_build_job_id: z.string().nullable().optional(), ledger_understanding_job_id: z.string().nullable().optional()});

export const reconciliationResult = z.object({result_type: z.literal("reconciliation").optional(), files_scanned: z.number().int(), discovered: z.array(z.string()).optional(), marked_stale: z.array(z.string()).optional(), orphans_removed: z.array(z.string()).optional(), ingestion_job_id: z.string().nullable().optional()});

export const knowledgeGraphFileFailure = z.object({path: z.string(), phase: z.enum(["classifying", "extracting"]), error: z.string()});

export const knowledgeGraphBuildResult = z.object({result_type: z.literal("kg_build").optional(), snapshot_id: z.string(), status: z.enum(["published", "empty_no_mentions"]).optional(), files_covered: z.number().int(), node_count: z.number().int().optional(), edge_count: z.number().int().optional(), rebuilt: z.boolean().optional(), files_failed: z.array(knowledgeGraphFileFailure).optional()});

export const autoDecisionWire = z.object({slot: z.string(), outcome: z.enum(["accepted_sole", "accepted_model", "suggested", "refused", "unanswered", "nominated"]), choice: z.string().nullable().optional(), confidence: z.enum(["high", "medium", "low"]).nullable().optional(), rationale: z.string().nullable().optional(), detail: z.string().optional()});

export const autoConfirmation = z.object({candidate_index: z.number().int().nullable().optional(), reason: z.string(), selection_id: z.string().nullable().optional()});

export const packageTieBreak = z.object({choice: z.string().nullable(), confidence: z.enum(["high", "medium", "low"]), rationale: z.array(z.string()).optional()});

export const pairedAmount = z.object({kind: z.literal("paired"), debit: z.string().min(1), credit: z.string().min(1)});

export const signedAmount = z.object({kind: z.literal("signed"), column: z.string().min(1)});

export const proposedStructure = z.object({journal_key: z.array(z.string()), account: z.array(z.string()), amount: z.discriminatedUnion("kind", [pairedAmount, signedAmount]), effective_date: z.string().nullable().optional(), period: z.string().nullable().optional(), line_ordinal: z.string().nullable().optional(), entity: z.string().nullable().optional()});

export const packageCandidate = z.object({primary_source_id: z.string(), supporting_source_ids: z.array(z.string()).optional(), trial_balance_source_id: z.string().nullable().optional(), user_master_source_id: z.string().nullable().optional(), structure: proposedStructure.nullable().optional(), confidence: z.enum(["high", "medium", "low"]), rationale: z.array(z.string()).optional(), warnings: z.array(z.string()).optional(), key_warning: z.string().nullable().optional()});

export const structureRoleConflict = z.object({column: z.string(), assigned_roles: z.array(z.string()), allowed: z.literal(false).optional(), resolution: z.string()});

export const rejectedCandidate = z.object({primary_source_id: z.string(), reason: z.string(), conflicts: z.array(structureRoleConflict).optional()});

export const ledgerPackageProposals = z.object({auto_confirmation: autoConfirmation.nullable().optional(), tie_break: packageTieBreak.nullable().optional(), candidates: z.array(packageCandidate).optional(), model_slug: z.string(), catalog_revision: z.string(), triaged_out: z.array(z.string()).optional(), warnings: z.array(z.string()).optional(), heuristic_fallback: z.boolean().optional(), triaged_out_count: z.number().int().optional(), rejected: z.array(rejectedCandidate).optional(), duration_ms: z.number().int().optional(), input_tokens: z.number().int().optional(), output_tokens: z.number().int().optional()});

export const ledgerPackageScope = z.object({path_prefix: z.string().nullable().optional(), paths: z.array(z.string()).optional(), selection_id: z.string().nullable().optional()});

export const procedureReadinessWire = z.object({status: z.enum(["ready", "limited", "unavailable", "unknown"]), reasons: z.array(z.string()).optional()});

export const keyAttempt = z.object({columns: z.array(z.string()), nominated_by: z.enum(["automatic", "human", "proposal", "model"]), outcome: z.enum(["qualified", "rejected", "unmeasured"]), reason: z.string(), null_counts: z.record(z.string(), z.number().int()).optional(), measured_rows: z.number().int().nullable().optional(), expected_rows: z.number().int(), balanced_share: z.number().nullable().optional()});

export const populationCandidateWire = z.object({attempts: z.array(keyAttempt).optional(), label: z.string(), tables: z.array(z.string()), paths: z.array(z.string()), member_count: z.number().int(), rows: z.number().int(), journal_key: z.array(z.string()).nullable().optional(), basis: z.string().nullable().optional(), balanced_share: z.number().nullable().optional(), selected: z.boolean(), classification: z.enum(["primary", "duplicate_projection", "supporting_reversal", "candidate"]).optional(), classification_reason: z.string().nullable().optional(), unresolved_reason: z.string().nullable().optional()});

export const ledgerAssessmentWire = z.object({status: z.enum(["ready", "limited", "needs_scope", "needs_source_selection", "needs_decision", "execution_failed", "unknown"]).optional(), reasons: z.array(z.string()).optional(), planned_checks: z.number().int().optional(), completed_checks: z.number().int().optional(), failed_checks: z.number().int().optional(), skipped_checks: z.number().int().optional(), not_run_checks: z.number().int().optional(), execution_coverage: z.number().nullable().optional(), procedures: z.record(z.string(), procedureReadinessWire).optional(), populations: z.array(populationCandidateWire).optional(), population_count: z.number().int().optional(), source_review_available: z.boolean().optional(), structure_review_available: z.boolean().optional(), header_status: z.enum(["not_required", "unmeasured", "complete", "partial", "unsafe", "failed"]).optional(), header_unmatched_lines: z.number().int().nullable().optional(), header_duplicate_keys: z.number().int().nullable().optional()});

export const appliedDecisionWire = z.object({kind: z.enum(["role_slot", "parse_signature", "period_mapping", "encoding_mapping"]), key: z.string(), outcome: z.enum(["applied", "orphaned", "conflict"]), detail: z.string().optional()});

export const valueCountWire = z.object({value: z.string(), rows: z.number().int()});

export const columnCardWire = z.object({name: z.string(), data_type: z.string(), role: z.string(), null_count: z.number().int(), blank_count: z.number().int().nullable().optional(), distinct_count: z.number().int().nullable().optional(), distinct_exact: z.boolean(), min_value: z.string().nullable().optional(), max_value: z.string().nullable().optional(), values: z.array(valueCountWire).nullable().optional()});

export const tableCardWire = z.object({path: z.string(), component: z.string().nullable().optional(), table_name: z.string(), role: z.string(), rows: z.number().int(), line_shaped: z.boolean(), partition_family: z.string().nullable().optional(), journal_key: z.array(z.string()).nullable().optional(), key_balanced_share: z.number().nullable().optional(), key_median_lines: z.number().nullable().optional(), columns: z.array(columnCardWire)});

export const basisWire = z.object({name: z.string(), shape: z.enum(["signed", "debit_credit_pair", "magnitude_with_direction"]), debit: z.string().nullable().optional(), credit: z.string().nullable().optional(), signed: z.string().nullable().optional(), magnitude: z.string().nullable().optional(), direction: z.string().nullable().optional(), debit_values: z.array(z.string()).optional(), credit_values: z.array(z.string()).optional(), currency: z.string().nullable().optional(), currency_scope: z.array(z.string()).optional(), balances_per_journal: z.number().nullable().optional(), ties_to_trial_balance: z.boolean().nullable().optional()});

export const roleSourceWire = z.object({table: z.string(), column: z.string(), evidence: z.string()});

export const conventionsWire = z.object({ledger_tables: z.array(z.string()), header_table: z.string().nullable().optional(), journal_key: z.array(z.string()).nullable().optional(), journal_key_aliases: z.array(z.string()).optional(), account_column: z.string().nullable().optional(), account_columns: z.array(z.string()).optional(), account_scope_columns: z.array(z.string()).optional(), account_identity_status: z.enum(["legacy", "scalar", "scoped", "blocked", "unmeasured"]).optional(), account_identity_reason: z.string().nullable().optional(), bases: z.array(basisWire), date_roles: z.record(z.string(), z.string()), auxiliary_columns: z.record(z.string(), z.array(z.string())).optional(), role_sources: z.record(z.string(), roleSourceWire).optional(), unavailable_tests: z.array(z.string()), header_columns: z.array(z.string()), line_columns: z.array(z.string()), entity_column: z.string().nullable().optional(), entity_values: z.array(z.string()), period_column: z.string().nullable().optional(), period_values: z.array(z.string()), layer_column: z.string().nullable().optional(), one_sided_entries: z.enum(["none", "present", "unknown"])});

export const integrityFindingWire = z.object({check: z.string(), severity: z.enum(["info", "warning", "blocking"]), table: z.string(), scope: z.string().nullable().optional(), count: z.number().int(), amount: z.string().nullable().optional(), sample_keys: z.array(z.string()), message: z.string()});

export const skippedCheckWire = z.object({check: z.string(), reason: z.string()});

export const checkExecutionWire = z.object({check: z.string(), table: z.string().nullable().optional(), scope: z.string().nullable().optional(), status: z.enum(["completed", "failed", "skipped", "not_run_due_to_resource_failure"]), resource_failure: z.enum(["spill_capacity", "memory"]).nullable().optional(), finding_count: z.number().int().optional(), reason: z.string().nullable().optional()});

export const integrityReportWire = z.object({findings: z.array(integrityFindingWire), skipped: z.array(skippedCheckWire), blocking: z.boolean(), executions: z.array(checkExecutionWire).nullable().optional()});

export const joinEdgeWire = z.object({left_table: z.string(), left_column: z.string(), right_table: z.string(), right_column: z.string(), left_columns: z.array(z.string()).optional(), right_columns: z.array(z.string()).optional(), left_tables: z.array(z.string()).optional(), left_null_rows: z.number().int().nullable().optional(), right_null_rows: z.number().int().nullable().optional(), right_duplicate_keys: z.number().int().nullable().optional(), left_in_right: z.number().nullable().optional(), right_in_left: z.number().nullable().optional(), unmatched_left: z.number().int().nullable().optional(), unmatched_right: z.number().int().nullable().optional()});

export const openQuestionWire = z.object({id: z.string(), slot: z.string(), question: z.string(), candidates: z.array(z.string()), evidence: z.array(z.string()), exclusive_group: z.string().nullable().optional()});

export const parseCapProfileWire = z.object({journals: z.number().int(), groups_median: z.number(), groups_p95: z.number(), groups_max: z.number().int(), lines_median: z.number(), lines_p95: z.number(), lines_max: z.number().int()});

export const mappingChange = z.object({role: z.enum(["journal_key", "account", "amount", "effective_date", "period", "line_ordinal"]), confirmed: z.array(z.string()), settled: z.array(z.string())});

export const structureProposal = z.object({journal_key: z.array(z.string()), amount: z.discriminatedUnion("kind", [pairedAmount, signedAmount]), account: z.union([z.string().min(1), z.array(z.string())]), effective_date: z.string().nullable().optional(), period: z.string().nullable().optional(), line_ordinal: z.string().nullable().optional()});

export const mappingConfirmationRequired = z.object({reason: z.enum(["model_confirmed_package", "mapping_changed"]), changes: z.array(mappingChange).optional(), proposed: structureProposal.nullable().optional()});

export const derivedTableWire = z.object({name: z.string(), row_count: z.number().int(), sha256: z.string()});

export const parseSummaryWire = z.object({resource_failure: z.enum(["spill_capacity", "memory"]).nullable().optional(), journals_total: z.number().int(), candidates: z.number().int(), attempted_candidates: z.number().int().optional(), candidate_coverage: z.number().nullable().optional(), population_capped_share: z.number().nullable().optional(), cap_reason_counts: z.record(z.string(), z.number().int()).optional(), cap_profiles: z.record(z.string(), parseCapProfileWire).optional(), candidates_capped: z.boolean(), population_capped: z.number().int(), parsed: z.number().int(), identity: z.number().int(), hub: z.number().int(), unbalanced: z.number().int(), capped: z.number().int(), solver_cap_hits: z.number().int(), sub_journals_total: z.number().int(), per_bucket: z.record(z.string(), z.number().int()), basis: z.string().nullable(), decimals: z.number().int().nullable(), parse_run_id: z.string().nullable(), duration_ms: z.number().int(), skipped_reason: z.string().nullable(), confirmation_required: mappingConfirmationRequired.nullable().optional(), tables: z.array(derivedTableWire)});

export const preparationSummaryWire = z.object({name: z.string(), status: z.enum(["ready", "unavailable", "failed"]), reason: z.string().nullable().optional(), reused: z.boolean().optional(), bucket_count: z.number().int().nullable().optional(), left_rows: z.number().int().nullable().optional(), right_rows: z.number().int().nullable().optional(), size_bytes: z.number().int().nullable().optional(), duration_ms: z.number().int().optional()});

export const ledgerUnderstandingReport = z.object({artifact_version: z.number().int().nullable().optional(), current_version: z.number().int().nullable().optional(), rerun_required: z.boolean().optional(), auto_decisions: z.array(autoDecisionWire).optional(), engine: z.enum(["measured", "llm"]).optional(), proposals: ledgerPackageProposals.nullable().optional(), reading_id: z.string().nullable().optional(), scope: ledgerPackageScope.optional(), assessment: ledgerAssessmentWire.optional(), package_fingerprint: z.string(), produced_at: z.string(), stale: z.boolean(), stale_reason: z.enum(["package", "version", "decisions"]).nullable().optional(), pending_decisions: z.number().int().optional(), applied_decisions: z.array(appliedDecisionWire).optional(), blocking: z.boolean(), tables: z.array(tableCardWire), conventions: conventionsWire, integrity: integrityReportWire, join_graph: z.array(joinEdgeWire), open_questions: z.array(openQuestionWire), parsing: parseSummaryWire.nullable().optional(), preparations: z.array(preparationSummaryWire).optional(), settled_structure: structureProposal.nullable().optional()});

export const ledgerUnderstandingResult = z.object({result_type: z.literal("ledger_understanding").optional(), follow_up_job_id: z.string().nullable().optional(), report: ledgerUnderstandingReport});

export const ledgerUnderstandingResetResult = z.object({result_type: z.literal("ledger_understanding_reset").optional(), workspace_id: z.string(), objects_deleted: z.number().int().optional(), decisions_deleted: z.number().int().optional(), jobs_cancelled: z.array(z.string()).optional(), verified: z.boolean().optional()});

export const ledgerParseExhibitsResult = z.object({result_type: z.literal("ledger_parse_exhibits").optional(), parse_run_id: z.string(), journals_total: z.number().int().gte(0)});

export const accessLabelSource = z.enum(["inherited", "classified", "mirrored"]);

export const file = z.object({file_id: z.string(), workspace_id: z.string(), path: z.string(), file_name: z.string(), file_type: z.string(), size_bytes: z.number().int(), observed_hash: z.string(), ingested_hash: z.string().nullable().optional(), ingestion_status: ingestionStatus, ingested_at: z.string().nullable().optional(), version: z.number().int(), category: z.string().nullable().optional(), access_label: z.string().nullable().optional(), access_label_source: accessLabelSource.nullable().optional(), expires_at: z.string().nullable().optional(), graph_inclusion: z.enum(["auto", "include", "exclude"]).optional(), labels: z.record(z.string(), z.string()).optional(), created_at: z.string(), updated_at: z.string()});

export const uploadFileResult = z.object({result_type: z.literal("file_upload").optional(), file: file, deduplicated: z.boolean()});

export const replaceFileResult = z.object({result_type: z.literal("file_replace").optional(), file: file, previous_version: z.number().int()});

export const deleteFileResult = z.object({result_type: z.literal("file_delete").optional(), file_id: z.string(), outputs_deleted: z.number().int().optional(), index_documents_deleted: z.number().int().optional(), kg_nodes_deleted: z.number().int().optional(), kg_edges_deleted: z.number().int().optional(), jobs_cancelled: z.array(z.string()).optional(), verified: z.boolean()});

export const fileDeletionOutcome = z.object({file_id: z.string(), path: z.string().nullable().optional(), status: z.enum(["deleted", "not_found", "access_denied"])});

export const deleteFilesResult = z.object({result_type: z.literal("files_delete").optional(), requested: z.number().int(), deleted: z.number().int(), outcomes: z.array(fileDeletionOutcome), outputs_deleted: z.number().int().optional(), index_documents_deleted: z.number().int().optional(), catalog_rows_deleted: z.number().int().optional(), objects_deleted: z.number().int().optional(), jobs_cancelled: z.array(z.string()).optional(), unverified_file_ids: z.array(z.string()).optional(), verified: z.boolean()});

export const workspaceDeleteResult = z.object({result_type: z.literal("workspace_delete").optional(), workspace_id: z.string(), files_deleted: z.number().int().optional(), index_documents_deleted: z.number().int().optional(), kg_nodes_deleted: z.number().int().optional(), prefix_deleted: z.boolean().optional(), verified: z.boolean().optional()});

export const tenantPurgeStore = z.enum(["jobs", "workspaces", "files", "upload_sessions", "profile_cache", "answer_cache", "catalog", "ledger_decisions", "parse_exports", "webhooks", "api_keys", "members", "users", "cli_sessions", "limit_overrides", "schemas_and_labels", "perception_cache", "storage", "redis"]);

export const tenantPurgeStoreReport = z.object({store: tenantPurgeStore, remaining: z.number().int().gte(0)});

export const tenantPurgeResult = z.object({result_type: z.literal("tenant_purge").optional(), tenant_id: z.string(), external_ref: z.string(), verified: z.boolean(), stores: z.array(tenantPurgeStoreReport), billing_record_kept: z.boolean()});

export const deepSearchClaimReference = z.object({kind: z.enum(["result_cell", "result_count", "result_absence", "command_result"]), result_id: z.string(), row: z.number().int().nullable().optional(), column: z.string().nullable().optional(), cited_value: z.string()});

export const deepSearchVerifiedClaim = z.object({claim_id: z.string(), answer_excerpt: z.string().nullable().optional(), answer_occurrence: z.number().int().gte(0).optional(), evidence_indices: z.array(z.number().int()).optional(), claim: z.string(), reference: deepSearchClaimReference});

export const commandReceipt = z.object({result_id: z.string(), command: z.string(), stdout: z.string(), outputs: z.record(z.string(), z.string())});

export const sqlTableBinding = z.object({path: z.string(), component: z.string().nullable().optional(), table_name: z.string(), source_sha256: z.string().nullable().optional()});

export const sqlReplayReceipt = z.object({schema_version: z.literal(1).optional(), kind: z.enum(["aggregate", "rowset"]), engine: z.literal("duckdb"), engine_version: z.string(), engine_threads: z.number().int().gt(0), normalized_sql: z.string(), sql_sha256: z.string(), logical_plan_sha256: z.string(), catalog_sha256: z.string(), result_artifact_sha256: z.string(), result_data_sha256: z.string(), result_digest_version: z.string(), result_dependencies: z.array(z.string()).optional()});

export const sqlReceipt = z.object({result_id: z.string(), sql: z.string(), handle: z.string().nullable().optional(), table_bindings: z.array(sqlTableBinding).optional(), replay: sqlReplayReceipt.nullable().optional(), columns: z.array(z.string()).optional(), rows: z.array(z.record(z.string(), z.string())).optional(), row_count: z.number().int().optional(), result_row_count: z.number().int().optional(), truncated: z.boolean().optional(), grounding_status: z.enum(["exact", "unavailable", "zero_result"]).nullable().optional(), views_used: z.array(z.string()).optional(), saved_as: z.string().nullable().optional(), view_sql: z.string().nullable().optional(), warnings: z.array(z.string()).optional(), executor: z.string().nullable().optional(), parameters: z.record(z.string(), z.string()).optional()});

export const derivationStep = z.object({result_id: z.string(), sql: z.string(), kind: z.enum(["extraction", "transformation"]), label: z.string(), preview_rows: z.array(z.record(z.string(), z.string())).optional(), reads: z.array(z.string()).optional()});

export const derivationTrace = z.object({steps: z.array(derivationStep).optional()});

export const searchEvidence = z.object({source_path: z.string(), source_file_id: z.string().nullable().optional(), page: z.number().int().nullable().optional(), component: z.string().nullable().optional(), quote: z.string(), passages: z.array(z.string()).optional(), relevance: z.string().optional(), queries: z.array(tableQueryGrounding).optional(), derivation: derivationTrace.nullable().optional()});

export const toolCallTrace = z.object({tool: z.string(), arguments_digest: z.string(), hits: z.number().int(), duration_ms: z.number().int()});

export const answerCacheInfo = z.object({served_from_cache: z.boolean(), source_job_id: z.string().nullable().optional(), cached_at: z.string(), verified_at: z.string()});

export const modelTokenUsage = z.object({model: z.string(), requests: z.number().int().optional(), input_tokens: z.number().int().optional(), output_tokens: z.number().int().optional(), cached_input_tokens: z.number().int().optional()});

export const searchLlmUsage = z.object({requests: z.number().int().optional(), input_tokens: z.number().int().optional(), output_tokens: z.number().int().optional(), cached_input_tokens: z.number().int().optional(), by_model: z.array(modelTokenUsage).optional()});

export const intelligentSearchResult = z.object({result_type: z.literal("intelligent_search").optional(), claims: z.array(deepSearchVerifiedClaim).optional(), command_receipts: z.array(commandReceipt).optional(), sql_receipts: z.array(sqlReceipt).optional(), evidences: z.array(searchEvidence).optional(), reasoning: z.string().nullable().optional(), answer: z.string().nullable().optional(), structured_answer: jsonValue.nullable().optional(), clarification: z.string().nullable().optional(), confidence: confidenceLevel.nullable().optional(), coverage: coverage.optional(), candidates_seen: z.number().int().optional(), steps_used: z.number().int().optional(), exhausted: z.boolean().optional(), tool_calls: z.array(toolCallTrace).optional(), session_id: z.string().nullable().optional(), cache: answerCacheInfo.nullable().optional(), usage: searchLlmUsage.nullable().optional(), grounding_job_ids: z.array(z.string()).nullable().optional()});

export const qaFileResult = z.object({result_type: z.literal("qa_file").optional(), steps_used: z.number().int().optional(), exhausted: z.boolean().optional(), answer: z.string().nullable().optional(), structured_answer: jsonValue.nullable().optional(), engine: z.enum(["recursive_llm", "vision", "agent"]).nullable().optional(), scope_path: z.string().nullable().optional(), scope_component: z.string().nullable().optional(), citations: z.array(evidence).optional(), unavailable: z.array(unavailableTable).optional(), timed_out: z.boolean().optional(), confidence: confidenceLevel.nullable().optional()});

export const qaTableResultFile = z.object({file_id: z.string(), handle: z.string(), path: z.string(), file_name: z.string(), format: z.literal("parquet").optional(), row_count: z.number().int(), sql: z.string(), source_paths: z.array(z.string()).optional(), grounding: tableQueryGrounding.nullable().optional(), download_url: z.string().nullable().optional(), preview_url: z.string().nullable().optional(), download_url_expires_at: z.string().nullable().optional()});

export const qaTablesResult = z.object({result_type: z.literal("qa_tables").optional(), steps_used: z.number().int().optional(), exhausted: z.boolean().optional(), answer: z.string().nullable().optional(), structured_answer: jsonValue.nullable().optional(), error: z.string().nullable().optional(), timed_out: z.boolean().optional(), source_paths: z.array(z.string()).optional(), source_components: z.array(z.string()).optional(), citations: z.array(evidence).optional(), tables: z.array(queryTablePreview).optional(), result_files: z.array(qaTableResultFile).optional(), result_materialization_error: z.string().nullable().optional(), unavailable: z.array(unavailableTable).optional(), confidence: confidenceLevel.nullable().optional()});

export const catalogColumnDescriptor = z.object({field: z.string(), kind: z.enum(["text", "date", "money", "number", "boolean"]), description: z.string().optional(), repeated: z.boolean().optional(), filtered: z.boolean().optional(), requested: z.boolean().optional()});

export const moneyCell = z.object({kind: z.literal("money").optional(), amount: z.string(), currency: z.string(), currency_source: z.enum(["stated", "assumed"]).optional()});

export const textCell = z.object({kind: z.literal("text").optional(), text: z.string()});

export const dateCell = z.object({kind: z.literal("date").optional(), date: z.string()});

export const numberCell = z.object({kind: z.literal("number").optional(), number: z.string()});

export const booleanCell = z.object({kind: z.literal("boolean").optional(), value: z.boolean()});

export const filteredSearchCell = z.object({field: z.string(), status: z.enum(["found", "not_found", "ambiguous", "unexamined"]), value: z.union([moneyCell, textCell, dateCell, numberCell, booleanCell]).nullable().optional(), item_index: z.number().int().optional(), citation: citation.nullable().optional(), native_raw: z.string().nullable().optional(), native_display: z.string().nullable().optional()});

export const contentEvidence = z.object({source_path: z.string(), source_file_id: z.string(), component: z.string().nullable().optional(), page: z.number().int().nullable().optional(), a1_range: z.string().nullable().optional(), quote: z.string()});

export const contentConditionMatch = z.object({condition: z.string(), value: z.string().nullable().optional(), evidences: z.array(contentEvidence)});

export const filteredSearchComponent = z.object({component: z.string(), component_kind: z.enum(["document", "sheet", "media"]), document_type: z.string().nullable().optional(), category: z.string().nullable().optional(), subcategory: z.string().nullable().optional(), page_start: z.number().int().nullable().optional(), page_end: z.number().int().nullable().optional(), summary: z.string().optional(), entity_id: z.string().nullable().optional(), source_row: z.number().int().nullable().optional(), cells: z.array(filteredSearchCell).optional(), content_matches: z.array(contentConditionMatch).optional()});

export const filteredSearchRow = z.object({component: z.string(), component_kind: z.enum(["document", "sheet", "media"]), document_type: z.string().nullable().optional(), category: z.string().nullable().optional(), subcategory: z.string().nullable().optional(), page_start: z.number().int().nullable().optional(), page_end: z.number().int().nullable().optional(), summary: z.string().optional(), entity_id: z.string().nullable().optional(), source_row: z.number().int().nullable().optional(), cells: z.array(filteredSearchCell).optional(), content_matches: z.array(contentConditionMatch).optional(), source_path: z.string(), source_file_id: z.string(), entry_id: z.string().nullable().optional(), components: z.array(filteredSearchComponent).optional()});

export const contentVerificationSummary = z.object({condition: z.string(), candidates: z.number().int().gte(0), unverified_candidates: z.number().int().gte(0)});

export const fieldReadability = z.object({field: z.string(), in_scope: z.number().int(), readable: z.number().int()});

export const filteredSearchResult = z.object({result_type: z.literal("filtered_search").optional(), result_unit: z.enum(["source", "component", "entity", "entry"]).optional(), columns: z.array(catalogColumnDescriptor).optional(), rows: z.array(filteredSearchRow).optional(), content_verification: contentVerificationSummary.nullable().optional(), total_matches: z.number().int().optional(), total_files: z.number().int().nullable().optional(), next_cursor: z.string().nullable().optional(), exhaustive: z.boolean().optional(), truncated: z.boolean().optional(), executed_at: z.string().nullable().optional(), catalog_drifted: z.boolean().optional(), applied_query: z.string().nullable().optional(), confidence: confidenceLevel.nullable().optional(), clarification: z.string().nullable().optional(), content_evidences: z.array(contentEvidence).optional(), evidences: z.array(searchEvidence).optional(), field_readability: z.array(fieldReadability).optional(), coverage: coverage.optional(), tool_calls: z.array(toolCallTrace).optional(), steps_used: z.number().int().optional(), exhausted: z.boolean().optional(), candidates_seen: z.number().int().optional()});

export const clarifyingQuestion = z.object({question: z.string(), options: z.array(z.string()).optional()});

export const jetBreakdown = z.object({columns: z.array(z.string()).optional(), rows: z.array(z.array(z.string())).optional(), truncated: z.boolean().optional(), result_id: z.string()});

export const jetFigure = z.object({criterion: z.string(), definition: z.string(), spec_id: z.string(), population: z.number().int().gte(0), count: z.number().int().gte(0), value: z.string().nullable().optional(), result_ids: z.array(z.string()).optional(), exception_listing_result_id: z.string().nullable().optional(), band_group: z.string().nullable().optional(), cannot_be_performed: z.boolean().optional(), breakdown: jetBreakdown.nullable().optional()});

export const jetCriterionOutcome = z.object({criterion_id: z.string().min(1), description: z.string().min(1), status: z.enum(["performed", "cannot_be_performed", "incomplete"]), spec_id: z.string().nullable().optional(), blocker: z.enum(["binding_unresolved", "measurement_failed", "missing_finding", "population_incomplete", "context_exhausted", "missing_business_parameter", "methodology_unresolved", "finding_unverified"]).nullable().optional(), incomplete_reason: z.enum(["binding_unresolved", "measurement_failed", "missing_finding"]).nullable().optional(), missing_parameters: z.array(z.enum(["close_cutoff", "balance_tolerance", "selected_user", "authority_limit", "methodology", "required_fields"])).optional()});

export const boundTable = z.object({role: z.string(), path: z.string(), component: z.string().nullable().optional(), table_name: z.string()});

export const boundColumn = z.object({slot: z.string(), path: z.string(), component: z.string().nullable().optional(), table_name: z.string(), column: z.string(), detail: z.string().nullable().optional()});

export const boundPeriod = z.object({value: z.string(), role: z.string()});

export const boundValueSet = z.object({slot: z.string(), name: z.string(), path: z.string(), component: z.string().nullable().optional(), table_name: z.string(), column: z.string(), values: z.array(z.string()).optional(), note: z.string().optional()});

export const ledgerBindingWire = z.object({tables: z.array(boundTable).optional(), policy_sheets: z.array(z.string()).optional(), columns: z.array(boundColumn).optional(), periods: z.array(boundPeriod).optional(), value_sets: z.array(boundValueSet).optional(), notes: z.array(z.string()).optional(), revised_because: z.string().nullable().optional()});

export const jetValidationWarning = z.object({check: z.enum(["specs", "scope", "cycle", "grain", "basis", "absence", "bands", "pointer", "delivery", "figures"]), status: z.literal("failed_open").optional()});

export const jetToolFailure = z.object({tool: z.string(), outcome: z.enum(["model_retry", "command_error", "timeout", "tool_error"]), count: z.number().int().gte(1)});

export const jetQuality = z.object({status: z.enum(["clean", "recovered_with_warnings", "degraded"]), validation_warnings: z.array(jetValidationWarning).optional(), tool_failures: z.array(jetToolFailure).optional(), missing_artifacts: z.array(z.enum(["binding", "sql_receipts"])).optional(), retried_checks: z.array(z.enum(["specs", "scope", "cycle", "grain", "basis", "absence", "bands", "pointer", "delivery", "figures"])).optional(), withheld_receipt_figures: z.number().int().gte(0).optional()});

export const jetAgentUsage = z.object({execution_requests: z.number().int().gte(0), compaction_requests: z.number().int().gte(0), finalization_requests: z.number().int().gte(0), total_requests: z.number().int().gte(0)});

export const jetResult = z.object({result_type: z.literal("je_testing").optional(), answer: z.string().nullable().optional(), clarification: z.string().nullable().optional(), clarification_questions: z.array(clarifyingQuestion).nullable().optional(), confidence: confidenceLevel.nullable().optional(), population_statement: z.string().nullable().optional(), figures: z.array(jetFigure).optional(), criteria: z.array(jetCriterionOutcome).optional(), discrepancies: z.array(z.string()).optional(), reasoning: z.string().nullable().optional(), evidences: z.array(searchEvidence).optional(), sql_receipts: z.array(sqlReceipt).optional(), binding: ledgerBindingWire.nullable().optional(), tool_calls: z.array(toolCallTrace).optional(), steps_used: z.number().int().optional(), exhausted: z.boolean().optional(), degraded: z.string().nullable().optional(), quality: jetQuality.nullable().optional(), execution_status: z.enum(["performed", "partially_performed", "not_performed"]).nullable().optional(), agent_usage: jetAgentUsage.nullable().optional(), spec_digest: z.string().nullable().optional(), session_id: z.string().nullable().optional(), usage: searchLlmUsage.nullable().optional(), grounding_job_ids: z.array(z.string()).nullable().optional()});

export const deepSearchCoverage = z.object({deliverable_id: z.string(), description: z.string(), basis: z.enum(["sql", "document", "calculation"]).optional(), evidence_indices: z.array(z.number().int()).optional(), status: z.enum(["answered", "partial", "unanswerable"]), claim_ids: z.array(z.string()).optional(), complete_result_id: z.string().nullable().optional(), complete_result: jetBreakdown.nullable().optional(), missing_inputs: z.array(z.string()).optional(), absence_result_ids: z.array(z.string()).optional()});

export const deepSearchV2Result = z.object({result_type: z.literal("deep_search_v2").optional(), answer: z.string().nullable().optional(), clarification: z.string().nullable().optional(), clarification_questions: z.array(clarifyingQuestion).nullable().optional(), confidence: confidenceLevel.nullable().optional(), population_statement: z.string().nullable().optional(), figures: z.array(jetFigure).optional(), criteria: z.array(jetCriterionOutcome).optional(), discrepancies: z.array(z.string()).optional(), reasoning: z.string().nullable().optional(), evidences: z.array(searchEvidence).optional(), sql_receipts: z.array(sqlReceipt).optional(), binding: ledgerBindingWire.nullable().optional(), tool_calls: z.array(toolCallTrace).optional(), steps_used: z.number().int().optional(), exhausted: z.boolean().optional(), degraded: z.string().nullable().optional(), quality: jetQuality.nullable().optional(), execution_status: z.enum(["performed", "partially_performed", "not_performed"]).nullable().optional(), agent_usage: jetAgentUsage.nullable().optional(), spec_digest: z.string().nullable().optional(), session_id: z.string().nullable().optional(), usage: searchLlmUsage.nullable().optional(), grounding_job_ids: z.array(z.string()).nullable().optional(), structured_answer: jsonValue.nullable().optional(), command_receipts: z.array(commandReceipt).optional(), claims: z.array(deepSearchVerifiedClaim).optional(), coverage: z.array(deepSearchCoverage).optional(), cache: answerCacheInfo.nullable().optional()});

export const automaticAgentResult = z.object({result_type: z.literal("automatic_agent").optional(), answer: deepSearchV2Result, catalog: filteredSearchResult.nullable().optional()});

export const automaticSearchResult = z.object({result_type: z.literal("automatic_search").optional(), output: z.discriminatedUnion("result_type", [intelligentSearchResult, automaticAgentResult, deepSearchV2Result, filteredSearchResult]), output_job_id: z.string(), routing: automaticSearchRouting, usage: searchLlmUsage.nullable().optional()});

export const resultState = z.enum(["available", "expired", "not_retained", "cancelled", "storage_unavailable"]);

export const costLine = z.object({operation: z.enum(["parse", "split", "classify", "extract", "ground"]), quantity: z.number().int().gte(0), unit: z.enum(["page", "item"]), execution: z.enum(["fresh", "reused"]), unit_price_usd: z.string(), amount_usd: z.string(), reuse_reason: z.enum(["reused_parse", "repeat_of_job"]).nullable().optional()});

export const jobCost = z.object({currency: z.literal("USD").optional(), pricing_version: z.string(), total_usd: z.string(), lines: z.array(costLine)});

export const usageWaiver = z.object({part: z.enum(["parse", "job"]), reason: z.enum(["reused_parse", "repeat_of_job"]), source_job_id: z.string().nullable().optional()});

export const usageLine = z.object({part: z.enum(["parse", "operation", "image_ocr"]), quantity: z.number().int().gte(0), unit: z.enum(["page", "item", "unit", "image"]), credits_per_unit: z.number().int().gte(0), multiplier: z.number().int().gte(1), credits: z.number().int().gte(0), waiver: usageWaiver.nullable().optional()});

export const jobUsage = z.object({lines: z.array(usageLine)});

export const job = z.object({job_id: z.string(), kind: jobKind, status: ndiServiceAppPlatformApiContractsJobStatus, name: z.string().nullable().optional(), project_id: z.string().nullable().optional(), workspace_id: z.string().nullable().optional(), idempotency_key: z.string().nullable().optional(), force: z.boolean().nullable().optional(), source: z.union([uploadSource, urlSource, workspaceFileSource, parseResultSource]).nullable().optional(), query: z.string().nullable().optional(), query_scope: z.union([workspaceQueryScope, fileQueryScope, pathPrefixQueryScope, filesQueryScope]).nullable().optional(), effort: z.string().nullable().optional(), surface: z.enum(["deep_search", "qa", "workbook"]).nullable().optional(), progress: jobProgress.nullable().optional(), result: z.union([storageConnectionValidationResult, folderMetadataResult, fileMetadataResult, readFileResult, hybridSearchResult, grepResult, runSqlResult, locateResult, ndiServiceAppPlatformApiResultsParseResult, splitResult, classifyResult, ndiServiceAppPlatformApiResultsCategorizeResult, ndiServiceAppPlatformApiResultsExtractResult, ndiServiceAppPlatformApiResultsGroundResult, ingestionResult, reconciliationResult, knowledgeGraphBuildResult, ledgerUnderstandingResult, ledgerUnderstandingResetResult, ledgerParseExhibitsResult, uploadFileResult, replaceFileResult, deleteFileResult, deleteFilesResult, workspaceDeleteResult, tenantPurgeResult, intelligentSearchResult, qaFileResult, qaTablesResult, filteredSearchResult, jetResult, deepSearchV2Result, automaticAgentResult, automaticSearchResult]).nullable().optional(), result_state: resultState.optional(), result_error: error.nullable().optional(), error: error.nullable().optional(), units: z.number().int().optional(), credits: z.number().int().nullable().optional(), usage_final: z.boolean().optional(), credit_schedule_version: z.number().int().nullable().optional(), usage_finalized_at: z.string().nullable().optional(), cost: jobCost.nullable().optional(), usage: jobUsage.nullable().optional(), created_at: z.string(), started_at: z.string().nullable().optional(), finished_at: z.string().nullable().optional(), payload_expires_at: z.string().nullable().optional(), deleted_at: z.string().nullable().optional()});

export const createApiV1WorkspacesWorkspaceIdToolsQaFileResponse = z.union([qaFileResponse, job]);

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * qa_file
 * 
 * POST /v1/workspaces/{workspace_id}/tools/qa-file
 */
export const createApiV1WorkspacesWorkspaceIdToolsQaFile = async (args: CreateApiV1WorkspacesWorkspaceIdToolsQaFileArgs, options: CreateApiV1WorkspacesWorkspaceIdToolsQaFileOptions) => {
const {baseUrl, fetch: fetchFn = fetch, APIKeyHeader} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('content-type', "application/json")
headers.set('accept', "application/json")

if (args.prefer != null) headers.set("prefer", String(args.prefer))
if (args['Idempotency-Key'] != null) headers.set("Idempotency-Key", String(args['Idempotency-Key']))
if (APIKeyHeader !== undefined) headers.set("X-API-Key", APIKeyHeader)

const url = `${baseUrl.replace(/\/+$/, '')}/v1/workspaces/${encodeURIComponent(String(args.workspace_id))}/tools/qa-file${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(createApiV1WorkspacesWorkspaceIdToolsQaFileResponse, await res.json())
};