import {z} from 'zod'

export type CreateApiV1PlaygroundParseArgs = {wait_seconds?: number | undefined, 'cf-turnstile-response'?: (string | null) | undefined, body: BodyInit};

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

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 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 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 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 jsonPointer = z.object({kind: z.literal("json_pointer").optional(), pointer: z.string()});

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 resultState = z.enum(["available", "expired", "not_retained", "cancelled", "storage_unavailable"]);

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 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 parseJob = z.object({job_id: z.string(), kind: z.literal("parse").optional(), 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: ndiServiceAppPlatformApiResultsParseResult.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 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
};

/**
 * playground_parse
 * 
 * POST /v1/playground/parse
 */
export const createApiV1PlaygroundParse = async (args: CreateApiV1PlaygroundParseArgs, options: CreateApiV1PlaygroundParseOptions) => {
const {baseUrl, fetch: fetchFn = fetch} = options ?? {}

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

if (args.wait_seconds != null) query.append("wait_seconds", String(args.wait_seconds))
if (args['cf-turnstile-response'] != null) headers.set("cf-turnstile-response", String(args['cf-turnstile-response']))

const url = `${baseUrl.replace(/\/+$/, '')}/v1/playground/parse${query.size > 0 ? `?${query}` : ''}`

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

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

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