import {z} from 'zod'

export type ClarificationAnswer = {question: string, answer?: (string | null) | undefined};

export type JsonValue = unknown;

export type QaRequest = {query: string, context?: (string | null) | undefined, path_prefix?: (string | null) | undefined, paths?: (Array<string> | null) | undefined, session_id?: (string | null) | undefined, allow_clarification?: boolean | undefined, clarification_answers?: (Array<ClarificationAnswer> | null) | undefined, output_schema?: ({[key: string]: JsonValue} | null) | undefined};

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

export type CreateApiV1WorkspacesWorkspaceIdQaOptions = {baseUrl: string, APIKeyHeader?: string | undefined, 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 clarifyingQuestion = z.object({question: z.string(), options: z.array(z.string()).optional()});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export const jsonValue = z.unknown();

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

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

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

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

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

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

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

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

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

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

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

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

export const 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 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 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 wordAnchor = z.object({part: z.string(), paragraph_index: z.number().int().gte(0), char_start: z.number().int().gte(0), char_end: z.number().int().gt(0)});

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

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

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

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

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

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

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

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

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

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

export const automaticAgentResult = z.object({result_type: z.literal("automatic_agent").optional(), answer: deepSearchV2Result, catalog: filteredSearchResult.nullable().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 qaJob = z.object({job_id: z.string(), kind: z.literal("automatic_agent").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: automaticAgentResult.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
};

/**
 * qa
 * 
 * POST /v1/workspaces/{workspace_id}/qa
 */
export const createApiV1WorkspacesWorkspaceIdQa = async (args: CreateApiV1WorkspacesWorkspaceIdQaArgs, options: CreateApiV1WorkspacesWorkspaceIdQaOptions) => {
const {baseUrl, fetch: fetchFn = fetch, APIKeyHeader} = options ?? {}

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

if (args.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/workspaces/${encodeURIComponent(String(args.workspace_id))}/qa${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(qaJob, await res.json())
};