import {z} from 'zod'

export type SplitInstanceKey = {description: string, name: string, required?: boolean | undefined};

export type SplitSubclass = {description?: string | undefined, id: string, label: string};

export type SplitCategory = {description?: string | undefined, id: string, instance_key?: (SplitInstanceKey | null) | undefined, label: string, subclasses?: Array<SplitSubclass> | undefined};

export type WorkspaceFileSource = {file_id: string, type?: 'workspace_file' | undefined, workspace_id: string};

export type SplitOutputOptions = {include_content?: boolean | undefined, materialize_files?: boolean | undefined};

export type PageRange = {end: number, start: number};

export type ParseDiagramsOptions = {mode?: ('omit' | 'mermaid') | undefined};

export type ParseSettingsFigures = {mode: 'omit' | 'include' | 'describe'};

export type ParseSpreadsheetOptions = {include_formulas?: boolean | undefined, include_hidden_columns?: boolean | undefined, include_hidden_rows?: boolean | undefined, include_hidden_sheets?: boolean | undefined, sheets?: (Array<string> | null) | undefined};

export type ParseSettings = {diagrams?: (ParseDiagramsOptions | null) | undefined, figures?: (ParseSettingsFigures | null) | undefined, page_ranges?: (Array<PageRange> | null) | undefined, parse_mode?: ('high' | 'medium' | 'low' | null) | undefined, spreadsheet?: (ParseSpreadsheetOptions | null) | undefined};

export type UploadSource = {type?: 'upload' | undefined, upload_id: string};

export type UrlSource = {file_name: string, type?: 'url' | undefined, url: string};

export type ParseResultSource = {job_id: string, type?: 'parse_result' | undefined};

export type SplitRequest = {classes: Array<SplitCategory>, corpus_sources?: Array<WorkspaceFileSource> | undefined, name?: (string | null) | undefined, output?: SplitOutputOptions | undefined, output_workspace_id?: (string | null) | undefined, overlap_policy?: ('exclusive' | 'shared_boundary_page') | undefined, page_ranges?: (Array<PageRange> | null) | undefined, parse?: (ParseSettings | null) | undefined, parse_mode?: ('low' | 'medium' | 'high') | undefined, project_id?: (string | null) | undefined, quality?: ('auto' | 'fast' | 'accurate') | undefined, source: UploadSource | UrlSource | WorkspaceFileSource | ParseResultSource, split_rules?: (string | null) | undefined, unknown_policy?: ('include' | 'force' | 'error') | undefined};

export type CreateApiV1SplitArgs = {wait_seconds?: number | undefined, 'Idempotency-Key'?: (string | null) | undefined, body: SplitRequest};

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

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

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

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, detail: z.record(z.string(), z.unknown()).nullable().optional(), message: z.string(), request_id: z.string().nullable().optional(), retryable: z.boolean()});

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 knowledgeGraphBuildProgress = z.object({countable: z.boolean(), documents: z.number().int().nullable().optional(), mentions: z.number().int().nullable().optional(), phase_count: z.number().int(), phase_index: z.number().int(), 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({decision_point: z.number().gte(0).lte(1), kind: z.literal("nacedm").optional(), p_agent: z.number().gte(0).lte(1).nullable()});

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

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

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

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

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

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

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

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

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

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

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

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

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

export const folderMetadataResponse = z.object({categories: z.array(categoryCount), coverage: coverage, credits: z.number().int().gte(0).nullable().optional(), directory: z.string(), file_entries: z.array(folderFileEntry), files_truncated: z.boolean(), hint: z.string().nullable().optional(), ingestion_summary: z.record(z.string(), z.number().int()), job_id: z.string().nullable().optional(), overall_files: z.number().int(), subdirectories: z.array(subdirectorySummary), waiver: z.enum(["repeat_of_job", "no_job"]).nullable().optional()});

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

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

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

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

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

export const fileReadCoverage = z.object({ocr_used: z.boolean(), pages_failed: z.number().int().gte(0), pages_read: z.number().int().gte(0)});

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

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

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

export const readFileResponse = z.object({components_omitted: z.array(z.string()), components_returned: z.array(z.string()), content: z.string(), credits: z.number().int().gte(0).nullable().optional(), file_id: z.string(), job_id: z.string().nullable().optional(), line_count: z.number().int().nullable().optional(), line_end: z.number().int().nullable().optional(), line_start: z.number().int().nullable().optional(), pages_returned: z.array(z.number().int()), path: z.string(), sql_tables: z.array(z.string()).optional(), table: grepTable.nullable().optional(), truncated: z.boolean(), waiver: z.enum(["repeat_of_job", "no_job"]).nullable().optional()});

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

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

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

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

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

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

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

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

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

export const searchResponse = z.object({candidates_seen: z.number().int(), coverage: coverage, credits: z.number().int().gte(0).nullable().optional(), hits: z.array(evidence), job_id: z.string().nullable().optional(), truncated: z.boolean(), waiver: z.enum(["repeat_of_job", "no_job"]).nullable().optional()});

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

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

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

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

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

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

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

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

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

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

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

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

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

export const runSqlResponse = z.object({credits: z.number().int().gte(0).nullable().optional(), duplicate: z.boolean().optional(), job_id: z.string().nullable().optional(), result: queryTablePreview, result_citation: queryTableCitation.nullable().optional(), result_materialization_error: z.string().nullable().optional(), source_paths: z.array(z.string()).optional(), sql: z.string(), waiver: z.enum(["repeat_of_job", "no_job"]).nullable().optional()});

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

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

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

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

export const locateResponse = z.object({credits: z.number().int().gte(0).nullable().optional(), job_id: z.string().nullable().optional(), pages: z.array(locatedPiece), population: z.array(locatedMember), population_unrated: z.number().int().optional(), tables: z.array(locatedTableRef), text: z.string(), waiver: z.enum(["repeat_of_job", "no_job"]).nullable().optional()});

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

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

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"), original_size: z.number().int().gte(1), retained_size: z.number().int().gte(0), target: truncationTarget, unit: truncationUnit});

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

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

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 textSpan = z.object({char_end: z.number().int().gte(0), char_start: z.number().int().gte(0), kind: z.literal("text_span").optional(), page: z.number().int().gte(1).nullable().optional()});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export const ledgerPackageProposals = z.object({auto_confirmation: autoConfirmation.nullable().optional(), candidates: z.array(packageCandidate).optional(), catalog_revision: z.string(), duration_ms: z.number().int().optional(), heuristic_fallback: z.boolean().optional(), input_tokens: z.number().int().optional(), model_slug: z.string(), output_tokens: z.number().int().optional(), rejected: z.array(rejectedCandidate).optional(), tie_break: packageTieBreak.nullable().optional(), triaged_out: z.array(z.string()).optional(), triaged_out_count: z.number().int().optional(), warnings: z.array(z.string()).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 valueCountWire = z.object({rows: z.number().int(), value: z.string()});

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

export const tableCardWire = z.object({columns: z.array(columnCardWire), component: 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(), line_shaped: z.boolean(), partition_family: z.string().nullable().optional(), path: z.string(), role: z.string(), rows: z.number().int(), table_name: z.string()});

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

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

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

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

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

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

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

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

export const deleteFileResult = z.object({file_id: z.string(), index_documents_deleted: z.number().int().optional(), jobs_cancelled: z.array(z.string()).optional(), kg_edges_deleted: z.number().int().optional(), kg_nodes_deleted: z.number().int().optional(), outputs_deleted: z.number().int().optional(), result_type: z.literal("file_delete").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({catalog_rows_deleted: z.number().int().optional(), deleted: z.number().int(), index_documents_deleted: z.number().int().optional(), jobs_cancelled: z.array(z.string()).optional(), objects_deleted: z.number().int().optional(), outcomes: z.array(fileDeletionOutcome), outputs_deleted: z.number().int().optional(), requested: z.number().int(), result_type: z.literal("files_delete").optional(), unverified_file_ids: z.array(z.string()).optional(), verified: z.boolean()});

export const workspaceDeleteResult = z.object({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(), result_type: z.literal("workspace_delete").optional(), verified: z.boolean().optional(), workspace_id: z.string()});

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({remaining: z.number().int().gte(0), store: tenantPurgeStore});

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

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

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

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

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

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

export const derivationStep = z.object({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(), result_id: z.string(), sql: z.string()});

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

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

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

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

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

export const jsonValue = z.unknown();

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

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

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

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

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

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

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

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

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

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

export const contentVerificationSummary = z.object({candidates: z.number().int().gte(0), condition: z.string(), 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 moneyCell = z.object({amount: z.string(), currency: z.string(), currency_source: z.enum(["stated", "assumed"]).optional(), kind: z.literal("money").optional()});

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

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

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({citation: citation.nullable().optional(), field: z.string(), item_index: z.number().int().optional(), native_display: z.string().nullable().optional(), native_raw: z.string().nullable().optional(), status: z.enum(["found", "not_found", "ambiguous", "unexamined"]), value: z.union([moneyCell, textCell, dateCell, numberCell, booleanCell]).nullable().optional()});

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

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

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

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

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

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

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

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

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

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

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

export const jetCriterionOutcome = z.object({blocker: z.enum(["binding_unresolved", "measurement_failed", "missing_finding", "population_incomplete", "context_exhausted", "missing_business_parameter", "methodology_unresolved", "finding_unverified"]).nullable().optional(), criterion_id: z.string().min(1), description: z.string().min(1), 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(), spec_id: z.string().nullable().optional(), status: z.enum(["performed", "cannot_be_performed", "incomplete"])});

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

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

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

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 jetQuality = z.object({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(), status: z.enum(["clean", "recovered_with_warnings", "degraded"]), tool_failures: z.array(jetToolFailure).optional(), validation_warnings: z.array(jetValidationWarning).optional(), withheld_receipt_figures: z.number().int().gte(0).optional()});

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

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

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

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

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

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

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

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

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

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

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

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({credits: z.number().int().gte(0), credits_per_unit: z.number().int().gte(0), multiplier: z.number().int().gte(1), part: z.enum(["parse", "operation", "image_ocr"]), quantity: z.number().int().gte(0), unit: z.enum(["page", "item", "unit", "image"]), waiver: usageWaiver.nullable().optional()});

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

export const job = z.object({cost: jobCost.nullable().optional(), created_at: z.string(), credit_schedule_version: z.number().int().nullable().optional(), credits: z.number().int().nullable().optional(), deleted_at: z.string().nullable().optional(), effort: z.string().nullable().optional(), error: error.nullable().optional(), finished_at: z.string().nullable().optional(), force: z.boolean().nullable().optional(), idempotency_key: z.string().nullable().optional(), job_id: z.string(), kind: jobKind, name: z.string().nullable().optional(), payload_expires_at: z.string().nullable().optional(), progress: jobProgress.nullable().optional(), project_id: z.string().nullable().optional(), query: z.string().nullable().optional(), query_scope: z.union([workspaceQueryScope, fileQueryScope, pathPrefixQueryScope, filesQueryScope]).nullable().optional(), replayed: z.boolean().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_error: error.nullable().optional(), result_state: resultState.optional(), source: z.union([uploadSource, urlSource, workspaceFileSource, parseResultSource]).nullable().optional(), started_at: z.string().nullable().optional(), status: ndiServiceAppPlatformApiContractsJobStatus, surface: z.enum(["deep_search", "qa", "workbook"]).nullable().optional(), units: z.number().int().optional(), usage: jobUsage.nullable().optional(), usage_final: z.boolean().optional(), usage_finalized_at: z.string().nullable().optional(), workspace_id: z.string().nullable().optional()});

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
};

/**
 * split
 * 
 * POST /v1/split
 */
export const createApiV1Split = async (args: CreateApiV1SplitArgs, options?: CreateApiV1SplitOptions) => {
const {baseUrl = "https://ndi-api.nace.ai", 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.wait_seconds != null) query.append("wait_seconds", String(args.wait_seconds))
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/split${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(job, await res.json())
};