dify/packages/contracts/generated/api/service/zod.gen.ts

// This file is auto-generated by @hey-api/openapi-ts

import * as z from 'zod'

/**
 * Annotation
 */
export const zAnnotation = z.object({
  content: z.string().nullish(),
  created_at: z.int().nullish(),
  hit_count: z.int().nullish(),
  id: z.string(),
  question: z.string().nullish(),
})

/**
 * AnnotationCreatePayload
 */
export const zAnnotationCreatePayload = z.object({
  answer: z.string(),
  question: z.string(),
})

/**
 * AnnotationJobStatusResponse
 */
export const zAnnotationJobStatusResponse = z.object({
  error_msg: z.string().nullish(),
  job_id: z.string(),
  job_status: z.string(),
})

/**
 * AnnotationList
 */
export const zAnnotationList = z.object({
  data: z.array(zAnnotation),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * AnnotationListQuery
 */
export const zAnnotationListQuery = z.object({
  keyword: z.string().optional().default(''),
  limit: z.int().gte(1).optional().default(20),
  page: z.int().gte(1).optional().default(1),
})

/**
 * AnnotationReplyActionPayload
 */
export const zAnnotationReplyActionPayload = z.object({
  embedding_model_name: z.string(),
  embedding_provider_name: z.string(),
  score_threshold: z.number(),
})

/**
 * AppFeedbackResponse
 */
export const zAppFeedbackResponse = z.object({
  app_id: z.string(),
  content: z.string().nullish(),
  conversation_id: z.string(),
  created_at: z.string(),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  message_id: z.string(),
  rating: z.string(),
  updated_at: z.string(),
})

/**
 * AppFeedbackListResponse
 */
export const zAppFeedbackListResponse = z.object({
  data: z.array(zAppFeedbackResponse),
})

/**
 * AppInfoResponse
 */
export const zAppInfoResponse = z.object({
  author_name: z.string().nullable(),
  description: z.string().nullable(),
  mode: z.string(),
  name: z.string(),
  tags: z.array(z.string()),
})

/**
 * AppMetaResponse
 */
export const zAppMetaResponse = z.object({
  tool_icons: z.record(z.string(), z.unknown()).optional(),
})

/**
 * AudioBinaryResponse
 */
export const zAudioBinaryResponse = z.custom<Blob | File>()

/**
 * AudioTranscriptResponse
 */
export const zAudioTranscriptResponse = z.object({
  text: z.string(),
})

/**
 * BinaryFileResponse
 */
export const zBinaryFileResponse = z.custom<Blob | File>()

/**
 * ButtonStyle
 *
 * Button styles for user actions.
 */
export const zButtonStyle = z.enum(['accent', 'default', 'ghost', 'primary'])

/**
 * ChatRequestPayload
 */
export const zChatRequestPayload = z.object({
  auto_generate_name: z.boolean().optional().default(true),
  conversation_id: z.string().nullish(),
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  inputs: z.record(z.string(), z.unknown()),
  query: z.string(),
  response_mode: z.enum(['blocking', 'streaming']).nullish(),
  retriever_from: z.string().optional().default('dev'),
  trace_session_id: z.string().nullish(),
  workflow_id: z.string().nullish(),
})

/**
 * ChildChunkCreatePayload
 */
export const zChildChunkCreatePayload = z.object({
  content: z.string(),
})

/**
 * ChildChunkListQuery
 */
export const zChildChunkListQuery = z.object({
  keyword: z.string().nullish(),
  limit: z.int().gte(1).optional().default(20),
  page: z.int().gte(1).optional().default(1),
})

/**
 * ChildChunkResponse
 */
export const zChildChunkResponse = z.object({
  content: z.string(),
  created_at: z.int(),
  id: z.string(),
  position: z.int(),
  segment_id: z.string(),
  type: z.string(),
  updated_at: z.int(),
  word_count: z.int(),
})

/**
 * ChildChunkDetailResponse
 */
export const zChildChunkDetailResponse = z.object({
  data: zChildChunkResponse,
})

/**
 * ChildChunkListResponse
 */
export const zChildChunkListResponse = z.object({
  data: z.array(zChildChunkResponse),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
  total_pages: z.int(),
})

/**
 * ChildChunkUpdatePayload
 */
export const zChildChunkUpdatePayload = z.object({
  content: z.string(),
})

/**
 * CompletionRequestPayload
 */
export const zCompletionRequestPayload = z.object({
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  inputs: z.record(z.string(), z.unknown()),
  query: z.string().optional().default(''),
  response_mode: z.enum(['blocking', 'streaming']).nullish(),
  retriever_from: z.string().optional().default('dev'),
  trace_session_id: z.string().nullish(),
})

/**
 * Condition
 *
 * Condition detail
 */
export const zCondition = z.object({
  comparison_operator: z.enum([
    '<',
    '=',
    '>',
    'after',
    'before',
    'contains',
    'empty',
    'end with',
    'in',
    'is',
    'is not',
    'not contains',
    'not empty',
    'not in',
    'start with',
    '≠',
    '≤',
    '≥',
  ]),
  name: z.string(),
  value: z.union([z.string(), z.array(z.string()), z.int(), z.number()]).nullish(),
})

/**
 * ConversationListQuery
 */
export const zConversationListQuery = z.object({
  last_id: z.string().nullish(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  sort_by: z
    .enum(['-created_at', '-updated_at', 'created_at', 'updated_at'])
    .optional()
    .default('-updated_at'),
})

/**
 * ConversationRenamePayload
 */
export const zConversationRenamePayload = z.object({
  auto_generate: z.boolean().optional().default(false),
  name: z.string().nullish(),
})

/**
 * ConversationVariableResponse
 */
export const zConversationVariableResponse = z.object({
  created_at: z.int().nullish(),
  description: z.string().nullish(),
  id: z.string(),
  name: z.string(),
  updated_at: z.int().nullish(),
  value: z.string().nullish(),
  value_type: z.string(),
})

/**
 * ConversationVariableInfiniteScrollPaginationResponse
 */
export const zConversationVariableInfiniteScrollPaginationResponse = z.object({
  data: z.array(zConversationVariableResponse),
  has_more: z.boolean(),
  limit: z.int(),
})

/**
 * ConversationVariableUpdatePayload
 */
export const zConversationVariableUpdatePayload = z.object({
  value: z.unknown(),
})

/**
 * ConversationVariablesQuery
 */
export const zConversationVariablesQuery = z.object({
  last_id: z.string().nullish(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  variable_name: z.string().min(1).max(255).nullish(),
})

/**
 * CustomConfigurationStatus
 *
 * Enum class for custom configuration status.
 */
export const zCustomConfigurationStatus = z.enum(['active', 'no-configure'])

/**
 * DatasetBoundTagResponse
 */
export const zDatasetBoundTagResponse = z.object({
  id: z.string(),
  name: z.string(),
})

/**
 * DatasetBoundTagListResponse
 */
export const zDatasetBoundTagListResponse = z.object({
  data: z.array(zDatasetBoundTagResponse),
  total: z.int(),
})

/**
 * DatasetDocMetadataResponse
 */
export const zDatasetDocMetadataResponse = z.object({
  id: z.string(),
  name: z.string(),
  type: z.string(),
})

/**
 * DatasetExternalKnowledgeInfoResponse
 */
export const zDatasetExternalKnowledgeInfoResponse = z.object({
  external_knowledge_api_endpoint: z.string().nullish(),
  external_knowledge_api_id: z.string().nullish(),
  external_knowledge_api_name: z.string().nullish(),
  external_knowledge_id: z.string().nullish(),
})

/**
 * DatasetExternalRetrievalModelResponse
 */
export const zDatasetExternalRetrievalModelResponse = z.object({
  score_threshold: z.number().nullish(),
  score_threshold_enabled: z.boolean().nullish(),
  top_k: z.int(),
})

/**
 * DatasetIconInfoResponse
 */
export const zDatasetIconInfoResponse = z.object({
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  icon_url: z.string().nullish(),
})

/**
 * DatasetKeywordSettingResponse
 */
export const zDatasetKeywordSettingResponse = z.object({
  keyword_weight: z.number().nullish(),
})

/**
 * DatasetListQuery
 */
export const zDatasetListQuery = z.object({
  include_all: z.boolean().optional().default(false),
  keyword: z.string().nullish(),
  limit: z.int().optional().default(20),
  page: z.int().optional().default(1),
  tag_ids: z.array(z.string()).optional(),
})

/**
 * DatasetMetadataActionResponse
 */
export const zDatasetMetadataActionResponse = z.object({
  result: z.string(),
})

/**
 * DatasetMetadataBuiltInFieldResponse
 */
export const zDatasetMetadataBuiltInFieldResponse = z.object({
  name: z.string(),
  type: z.string(),
})

/**
 * DatasetMetadataBuiltInFieldsResponse
 */
export const zDatasetMetadataBuiltInFieldsResponse = z.object({
  fields: z.array(zDatasetMetadataBuiltInFieldResponse),
})

/**
 * DatasetMetadataListItemResponse
 */
export const zDatasetMetadataListItemResponse = z.object({
  count: z.int().optional().default(0),
  id: z.string(),
  name: z.string(),
  type: z.string(),
})

/**
 * DatasetMetadataListResponse
 */
export const zDatasetMetadataListResponse = z.object({
  built_in_field_enabled: z.boolean(),
  doc_metadata: z.array(zDatasetMetadataListItemResponse),
})

/**
 * DatasetMetadataResponse
 */
export const zDatasetMetadataResponse = z.object({
  id: z.string(),
  name: z.string(),
  type: z.string(),
})

/**
 * DatasetRerankingModelResponse
 */
export const zDatasetRerankingModelResponse = z.object({
  reranking_model_name: z.string().nullish(),
  reranking_provider_name: z.string().nullish(),
})

/**
 * DatasetSummaryIndexSettingResponse
 */
export const zDatasetSummaryIndexSettingResponse = z.object({
  enable: z.boolean().nullish(),
  model_name: z.string().nullish(),
  model_provider_name: z.string().nullish(),
  summary_prompt: z.string().nullish(),
})

/**
 * DatasetTagResponse
 */
export const zDatasetTagResponse = z.object({
  id: z.string(),
  name: z.string(),
  type: z.string(),
})

/**
 * DatasetVectorSettingResponse
 */
export const zDatasetVectorSettingResponse = z.object({
  embedding_model_name: z.string().nullish(),
  embedding_provider_name: z.string().nullish(),
  vector_weight: z.number().nullish(),
})

/**
 * DatasetWeightedScoreResponse
 */
export const zDatasetWeightedScoreResponse = z.object({
  keyword_setting: zDatasetKeywordSettingResponse.optional(),
  vector_setting: zDatasetVectorSettingResponse.optional(),
  weight_type: z.string().nullish(),
})

/**
 * DatasetRetrievalModelResponse
 */
export const zDatasetRetrievalModelResponse = z.object({
  reranking_enable: z.boolean(),
  reranking_mode: z.string().nullish(),
  reranking_model: zDatasetRerankingModelResponse.optional(),
  score_threshold: z.number().nullish(),
  score_threshold_enabled: z.boolean(),
  search_method: z.string(),
  top_k: z.int(),
  weights: zDatasetWeightedScoreResponse.nullish(),
})

/**
 * DatasetDetailResponse
 */
export const zDatasetDetailResponse = z.object({
  app_count: z.int(),
  author_name: z.string().nullable(),
  built_in_field_enabled: z.boolean(),
  chunk_structure: z.string().nullable(),
  created_at: z.int(),
  created_by: z.string(),
  data_source_type: z.string().nullable(),
  description: z.string().nullable(),
  doc_form: z.string().nullable(),
  doc_metadata: z.array(zDatasetDocMetadataResponse),
  document_count: z.int(),
  embedding_available: z.boolean().nullish(),
  embedding_model: z.string().nullable(),
  embedding_model_provider: z.string().nullable(),
  enable_api: z.boolean(),
  external_knowledge_info: zDatasetExternalKnowledgeInfoResponse.optional(),
  external_retrieval_model: zDatasetExternalRetrievalModelResponse.nullable(),
  icon_info: zDatasetIconInfoResponse.optional(),
  id: z.string(),
  indexing_technique: z.string().nullable(),
  is_multimodal: z.boolean(),
  is_published: z.boolean(),
  name: z.string(),
  permission: z.string(),
  pipeline_id: z.string().nullable(),
  provider: z.string(),
  retrieval_model_dict: zDatasetRetrievalModelResponse,
  runtime_mode: z.string().nullable(),
  summary_index_setting: zDatasetSummaryIndexSettingResponse.optional(),
  tags: z.array(zDatasetTagResponse),
  total_available_documents: z.int(),
  total_documents: z.int(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  word_count: z.int(),
})

/**
 * DatasetDetailWithPartialMembersResponse
 */
export const zDatasetDetailWithPartialMembersResponse = z.object({
  app_count: z.int(),
  author_name: z.string().nullable(),
  built_in_field_enabled: z.boolean(),
  chunk_structure: z.string().nullable(),
  created_at: z.int(),
  created_by: z.string(),
  data_source_type: z.string().nullable(),
  description: z.string().nullable(),
  doc_form: z.string().nullable(),
  doc_metadata: z.array(zDatasetDocMetadataResponse),
  document_count: z.int(),
  embedding_available: z.boolean().nullish(),
  embedding_model: z.string().nullable(),
  embedding_model_provider: z.string().nullable(),
  enable_api: z.boolean(),
  external_knowledge_info: zDatasetExternalKnowledgeInfoResponse.optional(),
  external_retrieval_model: zDatasetExternalRetrievalModelResponse.nullable(),
  icon_info: zDatasetIconInfoResponse.optional(),
  id: z.string(),
  indexing_technique: z.string().nullable(),
  is_multimodal: z.boolean(),
  is_published: z.boolean(),
  name: z.string(),
  partial_member_list: z.array(z.string()).nullish(),
  permission: z.string(),
  pipeline_id: z.string().nullable(),
  provider: z.string(),
  retrieval_model_dict: zDatasetRetrievalModelResponse,
  runtime_mode: z.string().nullable(),
  summary_index_setting: zDatasetSummaryIndexSettingResponse.optional(),
  tags: z.array(zDatasetTagResponse),
  total_available_documents: z.int(),
  total_documents: z.int(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  word_count: z.int(),
})

/**
 * DatasetListResponse
 */
export const zDatasetListResponse = z.object({
  data: z.array(zDatasetDetailResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * DatasourceCredentialInfoResponse
 */
export const zDatasourceCredentialInfoResponse = z.object({
  id: z.string().nullish(),
  is_default: z.boolean().nullish(),
  name: z.string().nullish(),
  type: z.string().nullish(),
})

/**
 * DatasourceNodeRunPayload
 */
export const zDatasourceNodeRunPayload = z.object({
  credential_id: z.string().nullish(),
  datasource_type: z.string(),
  inputs: z.record(z.string(), z.unknown()),
  is_published: z.boolean(),
})

/**
 * DatasourcePluginResponse
 */
export const zDatasourcePluginResponse = z.object({
  credentials: z.array(zDatasourceCredentialInfoResponse),
  datasource_type: z.string().nullish(),
  node_id: z.string().nullish(),
  plugin_id: z.string().nullish(),
  provider_name: z.string().nullish(),
  title: z.string().nullish(),
  user_input_variables: z.array(z.record(z.string(), z.unknown())).optional(),
})

/**
 * DatasourcePluginListResponse
 */
export const zDatasourcePluginListResponse = z.array(zDatasourcePluginResponse)

/**
 * DatasourcePluginsQuery
 */
export const zDatasourcePluginsQuery = z.object({
  is_published: z.boolean().optional().default(true),
})

/**
 * DocumentBatchDownloadZipPayload
 *
 * Request payload for bulk downloading documents as a zip archive.
 */
export const zDocumentBatchDownloadZipPayload = z.object({
  document_ids: z.array(z.uuid()).min(1).max(100),
})

/**
 * DocumentGetQuery
 */
export const zDocumentGetQuery = z.object({
  metadata: z.enum(['all', 'only', 'without']).optional().default('all'),
})

/**
 * DocumentListQuery
 */
export const zDocumentListQuery = z.object({
  keyword: z.string().nullish(),
  limit: z.int().optional().default(20),
  page: z.int().optional().default(1),
  status: z.string().nullish(),
})

/**
 * DocumentMetadataResponse
 */
export const zDocumentMetadataResponse = z.object({
  id: z.string(),
  name: z.string(),
  type: z.string(),
  value: z.union([z.string(), z.int(), z.number(), z.boolean()]).nullish(),
})

/**
 * DocumentDetailResponse
 */
export const zDocumentDetailResponse = z.object({
  archived: z.boolean().nullish(),
  average_segment_length: z.number().nullish(),
  completed_at: z.int().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  created_from: z.string().nullish(),
  data_source_info: z.record(z.string(), z.unknown()).nullish(),
  data_source_type: z.string().nullish(),
  dataset_process_rule: z.record(z.string(), z.unknown()).nullish(),
  dataset_process_rule_id: z.string().nullish(),
  disabled_at: z.int().nullish(),
  disabled_by: z.string().nullish(),
  display_status: z.string().nullish(),
  doc_form: z.string().nullish(),
  doc_language: z.string().nullish(),
  doc_metadata: z.array(zDocumentMetadataResponse).nullish(),
  doc_type: z.string().nullish(),
  document_process_rule: z.record(z.string(), z.unknown()).nullish(),
  enabled: z.boolean().nullish(),
  error: z.string().nullish(),
  hit_count: z.int().nullish(),
  id: z.string(),
  indexing_latency: z.number().nullish(),
  indexing_status: z.string().nullish(),
  name: z.string().nullish(),
  need_summary: z.boolean().nullish(),
  position: z.int().nullish(),
  segment_count: z.int().nullish(),
  summary_index_status: z.string().nullish(),
  tokens: z.int().nullish(),
  updated_at: z.int().nullish(),
})

/**
 * DocumentResponse
 */
export const zDocumentResponse = z.object({
  archived: z.boolean().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  created_from: z.string().nullish(),
  data_source_detail_dict: z.unknown().optional(),
  data_source_info: z.unknown().optional(),
  data_source_type: z.string().nullish(),
  dataset_process_rule_id: z.string().nullish(),
  disabled_at: z.int().nullish(),
  disabled_by: z.string().nullish(),
  display_status: z.string().nullish(),
  doc_form: z.string().nullish(),
  doc_metadata: z.array(zDocumentMetadataResponse).optional(),
  enabled: z.boolean().nullish(),
  error: z.string().nullish(),
  hit_count: z.int().nullish(),
  id: z.string(),
  indexing_status: z.string().nullish(),
  name: z.string(),
  need_summary: z.boolean().nullish(),
  position: z.int().nullish(),
  summary_index_status: z.string().nullish(),
  tokens: z.int().nullish(),
  word_count: z.int().nullish(),
})

/**
 * DocumentAndBatchResponse
 */
export const zDocumentAndBatchResponse = z.object({
  batch: z.string(),
  document: zDocumentResponse,
})

/**
 * DocumentListResponse
 */
export const zDocumentListResponse = z.object({
  data: z.array(zDocumentResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * DocumentStatusPayload
 */
export const zDocumentStatusPayload = z.object({
  document_ids: z.array(z.string()).optional(),
})

/**
 * DocumentStatusResponse
 */
export const zDocumentStatusResponse = z.object({
  cleaning_completed_at: z.int().nullable(),
  completed_at: z.int().nullable(),
  completed_segments: z.int().nullish(),
  error: z.string().nullable(),
  id: z.string(),
  indexing_status: z.string(),
  parsing_completed_at: z.int().nullable(),
  paused_at: z.int().nullable(),
  processing_started_at: z.int().nullable(),
  splitting_completed_at: z.int().nullable(),
  stopped_at: z.int().nullable(),
  total_segments: z.int().nullish(),
})

/**
 * DocumentStatusListResponse
 */
export const zDocumentStatusListResponse = z.object({
  data: z.array(zDocumentStatusResponse),
})

/**
 * EndUserDetail
 *
 * Full EndUser record for API responses.
 *
 * Note: The SQLAlchemy model defines an `is_anonymous` property for Flask-Login semantics
 * (always False). The database column is exposed as `_is_anonymous`, so this DTO maps
 * `is_anonymous` from `_is_anonymous` to return the stored value.
 */
export const zEndUserDetail = z.object({
  app_id: z.string().nullish(),
  created_at: z.iso.datetime(),
  external_user_id: z.string().nullish(),
  id: z.string(),
  is_anonymous: z.boolean(),
  name: z.string().nullish(),
  session_id: z.string(),
  tenant_id: z.string(),
  type: z.string(),
  updated_at: z.iso.datetime(),
})

/**
 * EventStreamResponse
 */
export const zEventStreamResponse = z.string()

/**
 * ExecutionContentType
 */
export const zExecutionContentType = z.enum(['human_input'])

/**
 * FeedbackListQuery
 */
export const zFeedbackListQuery = z.object({
  limit: z.int().gte(1).lte(101).optional().default(20),
  page: z.int().gte(1).optional().default(1),
})

/**
 * FetchFrom
 *
 * Enum class for fetch from.
 */
export const zFetchFrom = z.enum(['customizable-model', 'predefined-model'])

/**
 * FilePreviewQuery
 */
export const zFilePreviewQuery = z.object({
  as_attachment: z.boolean().optional().default(false),
})

/**
 * FileResponse
 */
export const zFileResponse = z.object({
  conversation_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  extension: z.string().nullish(),
  file_key: z.string().nullish(),
  id: z.string(),
  mime_type: z.string().nullish(),
  name: z.string(),
  original_url: z.string().nullish(),
  preview_url: z.string().nullish(),
  reference: z.string().nullish(),
  size: z.int(),
  source_url: z.string().nullish(),
  tenant_id: z.string().nullish(),
  user_id: z.string().nullish(),
})

/**
 * FileTransferMethod
 */
export const zFileTransferMethod = z.enum([
  'datasource_file',
  'local_file',
  'remote_url',
  'tool_file',
])

/**
 * FileType
 */
export const zFileType = z.enum(['audio', 'custom', 'document', 'image', 'video'])

/**
 * FileInputConfig
 */
export const zFileInputConfig = z.object({
  allowed_file_extensions: z.array(z.string()).optional(),
  allowed_file_types: z.array(zFileType).optional(),
  allowed_file_upload_methods: z.array(zFileTransferMethod).optional(),
  output_variable_name: z.string(),
  type: z.literal('file').optional().default('file'),
})

/**
 * FileListInputConfig
 */
export const zFileListInputConfig = z.object({
  allowed_file_extensions: z.array(z.string()).optional(),
  allowed_file_types: z.array(zFileType).optional(),
  allowed_file_upload_methods: z.array(zFileTransferMethod).optional(),
  number_limits: z.int().gte(0).optional().default(0),
  output_variable_name: z.string(),
  type: z.literal('file-list').optional().default('file-list'),
})

/**
 * HitTestingChildChunk
 */
export const zHitTestingChildChunk = z.object({
  content: z.string(),
  id: z.string(),
  position: z.int(),
  score: z.number(),
})

/**
 * HitTestingDocument
 */
export const zHitTestingDocument = z.object({
  data_source_type: z.string(),
  doc_metadata: z.unknown().nullable(),
  doc_type: z.string().nullable(),
  id: z.string(),
  name: z.string(),
})

/**
 * HitTestingFile
 */
export const zHitTestingFile = z.object({
  extension: z.string(),
  id: z.string(),
  mime_type: z.string(),
  name: z.string(),
  size: z.int(),
  source_url: z.string(),
})

/**
 * HitTestingQuery
 */
export const zHitTestingQuery = z.object({
  content: z.string(),
})

/**
 * HitTestingSegment
 */
export const zHitTestingSegment = z.object({
  answer: z.string().nullable(),
  completed_at: z.int().nullable(),
  content: z.string(),
  created_at: z.int(),
  created_by: z.string(),
  disabled_at: z.int().nullable(),
  disabled_by: z.string().nullable(),
  document: zHitTestingDocument,
  document_id: z.string(),
  enabled: z.boolean(),
  error: z.string().nullable(),
  hit_count: z.int(),
  id: z.string(),
  index_node_hash: z.string().nullable(),
  index_node_id: z.string().nullable(),
  indexing_at: z.int().nullable(),
  keywords: z.array(z.string()),
  position: z.int(),
  sign_content: z.string().nullable(),
  status: z.string(),
  stopped_at: z.int().nullable(),
  tokens: z.int(),
  word_count: z.int(),
})

/**
 * HitTestingRecord
 */
export const zHitTestingRecord = z.object({
  child_chunks: z.array(zHitTestingChildChunk),
  files: z.array(zHitTestingFile),
  score: z.number().nullable(),
  segment: zHitTestingSegment,
  summary: z.string().nullable(),
  tsne_position: z.unknown().nullable(),
})

/**
 * HitTestingResponse
 */
export const zHitTestingResponse = z.object({
  query: zHitTestingQuery,
  records: z.array(zHitTestingRecord),
})

/**
 * HumanInputFormDefinitionResponse
 */
export const zHumanInputFormDefinitionResponse = z.object({
  expiration_time: z.int().nullish(),
  form_content: z.string(),
  inputs: z.array(z.record(z.string(), z.unknown())).optional(),
  resolved_default_values: z.record(z.string(), z.string()),
  user_actions: z.array(z.record(z.string(), z.unknown())).optional(),
})

/**
 * HumanInputFormSubmitResponse
 */
export const zHumanInputFormSubmitResponse = z.record(z.string(), z.never())

/**
 * I18nObject
 *
 * Model class for i18n object.
 */
export const zI18nObject = z.object({
  en_US: z.string(),
  zh_Hans: z.string().nullish(),
})

/**
 * IndexInfoResponse
 */
export const zIndexInfoResponse = z.object({
  api_version: z.string(),
  server_version: z.string(),
  welcome: z.string(),
})

export const zJsonObject = z.record(z.string(), z.unknown())

export const zJsonValue = z
  .union([
    z.string(),
    z.int(),
    z.number(),
    z.boolean(),
    z.record(z.string(), z.unknown()),
    z.array(z.unknown()),
  ])
  .nullable()

/**
 * AgentThought
 */
export const zAgentThought = z.object({
  chain_id: z.string().nullish(),
  created_at: z.int().nullish(),
  files: z.array(z.string()),
  id: z.string(),
  message_id: z.string(),
  observation: z.string().nullish(),
  position: z.int(),
  thought: z.string().nullish(),
  tool: z.string().nullish(),
  tool_input: z.string().nullish(),
  tool_labels: zJsonValue,
})

/**
 * GeneratedAppResponse
 */
export const zGeneratedAppResponse = zJsonValue

export const zJsonValueType = z.unknown()

export const zJsonValue2 = z.unknown()

/**
 * HumanInputFormSubmissionData
 */
export const zHumanInputFormSubmissionData = z.object({
  action_id: z.string(),
  action_text: z.string(),
  node_id: z.string(),
  node_title: z.string(),
  rendered_content: z.string(),
  submitted_data: z.record(z.string(), zJsonValue2).nullish(),
})

/**
 * HumanInputFormSubmitPayload
 */
export const zHumanInputFormSubmitPayload = z.object({
  action: z.string(),
  inputs: z.record(z.string(), zJsonValue2),
})

/**
 * KnowledgeTagResponse
 */
export const zKnowledgeTagResponse = z.object({
  binding_count: z.string().nullish(),
  id: z.string(),
  name: z.string(),
  type: z.string(),
})

/**
 * KnowledgeTagListResponse
 */
export const zKnowledgeTagListResponse = z.array(zKnowledgeTagResponse)

/**
 * MessageFeedbackPayload
 */
export const zMessageFeedbackPayload = z.object({
  content: z.string().nullish(),
  rating: z.enum(['dislike', 'like']).nullish(),
})

/**
 * MessageFile
 */
export const zMessageFile = z.object({
  belongs_to: z.string().nullish(),
  filename: z.string(),
  id: z.string(),
  mime_type: z.string().nullish(),
  size: z.int().nullish(),
  transfer_method: z.string(),
  type: z.string(),
  upload_file_id: z.string().nullish(),
  url: z.string().nullish(),
})

/**
 * MessageListQuery
 */
export const zMessageListQuery = z.object({
  conversation_id: z.string(),
  first_id: z.string().nullish(),
  limit: z.int().gte(1).lte(100).optional().default(20),
})

/**
 * MetadataArgs
 */
export const zMetadataArgs = z.object({
  name: z.string(),
  type: z.enum(['number', 'string', 'time']),
})

/**
 * MetadataDetail
 */
export const zMetadataDetail = z.object({
  id: z.string(),
  name: z.string(),
  value: z.union([z.string(), z.int(), z.number()]).nullish(),
})

/**
 * DocumentMetadataOperation
 */
export const zDocumentMetadataOperation = z.object({
  document_id: z.string(),
  metadata_list: z.array(zMetadataDetail),
  partial_update: z.boolean().optional().default(false),
})

/**
 * MetadataFilteringCondition
 *
 * Metadata Filtering Condition.
 */
export const zMetadataFilteringCondition = z.object({
  conditions: z.array(zCondition).nullish(),
  logical_operator: z.enum(['and', 'or']).nullish().default('and'),
})

/**
 * MetadataOperationData
 *
 * Metadata operation data
 */
export const zMetadataOperationData = z.object({
  operation_data: z.array(zDocumentMetadataOperation),
})

/**
 * MetadataUpdatePayload
 */
export const zMetadataUpdatePayload = z.object({
  name: z.string(),
})

/**
 * ModelFeature
 *
 * Enum class for llm feature.
 */
export const zModelFeature = z.enum([
  'agent-thought',
  'audio',
  'document',
  'multi-tool-call',
  'polling',
  'stream-tool-call',
  'structured-output',
  'tool-call',
  'video',
  'vision',
])

/**
 * ModelPropertyKey
 *
 * Enum class for model property key.
 */
export const zModelPropertyKey = z.enum([
  'audio_type',
  'context_size',
  'default_voice',
  'file_upload_limit',
  'max_characters_per_chunk',
  'max_chunks',
  'max_workers',
  'mode',
  'supported_file_extensions',
  'voices',
  'word_limit',
])

/**
 * ModelStatus
 *
 * Enum class for model status.
 */
export const zModelStatus = z.enum([
  'active',
  'credential-removed',
  'disabled',
  'no-configure',
  'no-permission',
  'quota-exceeded',
])

/**
 * ModelType
 *
 * Enum class for model type.
 */
export const zModelType = z.enum([
  'llm',
  'moderation',
  'rerank',
  'speech2text',
  'text-embedding',
  'tts',
])

/**
 * PermissionEnum
 *
 * Shared permission levels for resources (datasets, credentials, etc.)
 */
export const zPermissionEnum = z.enum(['all_team_members', 'only_me', 'partial_members'])

/**
 * PipelineRunApiEntity
 */
export const zPipelineRunApiEntity = z.object({
  datasource_info_list: z.array(z.record(z.string(), z.unknown())),
  datasource_type: z.string(),
  inputs: z.record(z.string(), z.unknown()),
  is_published: z.boolean(),
  response_mode: z.string(),
  start_node_id: z.string(),
})

/**
 * PipelineUploadFileResponse
 */
export const zPipelineUploadFileResponse = z.object({
  created_at: z.string().nullish(),
  created_by: z.string(),
  extension: z.string(),
  id: z.string(),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int(),
})

/**
 * PreProcessingRule
 */
export const zPreProcessingRule = z.object({
  enabled: z.boolean(),
  id: z.string(),
})

/**
 * ProcessRuleMode
 *
 * Dataset Process Rule Mode
 */
export const zProcessRuleMode = z.enum(['automatic', 'custom', 'hierarchical'])

/**
 * ProviderModelWithStatusEntity
 *
 * Model class for model response.
 */
export const zProviderModelWithStatusEntity = z.object({
  deprecated: z.boolean().optional().default(false),
  features: z.array(zModelFeature).nullish(),
  fetch_from: zFetchFrom,
  has_invalid_load_balancing_configs: z.boolean().optional().default(false),
  label: zI18nObject,
  load_balancing_enabled: z.boolean().optional().default(false),
  model: z.string(),
  model_properties: z.record(z.string(), z.unknown()),
  model_type: zModelType,
  status: zModelStatus,
})

/**
 * ProviderWithModelsResponse
 *
 * Model class for provider with models response.
 */
export const zProviderWithModelsResponse = z.object({
  icon_small: zI18nObject.nullish(),
  icon_small_dark: zI18nObject.nullish(),
  label: zI18nObject,
  models: z.array(zProviderModelWithStatusEntity),
  provider: z.string(),
  status: zCustomConfigurationStatus,
  tenant_id: z.string(),
})

/**
 * ProviderWithModelsListResponse
 */
export const zProviderWithModelsListResponse = z.object({
  data: z.array(zProviderWithModelsResponse),
})

/**
 * RerankingModel
 */
export const zRerankingModel = z.object({
  reranking_model_name: z.string().nullish(),
  reranking_provider_name: z.string().nullish(),
})

/**
 * ResultResponse
 */
export const zResultResponse = z.object({
  result: z.string(),
})

/**
 * RetrievalMethod
 */
export const zRetrievalMethod = z.enum([
  'full_text_search',
  'hybrid_search',
  'keyword_search',
  'semantic_search',
])

/**
 * RetrieverResource
 */
export const zRetrieverResource = z.object({
  content: z.string().nullish(),
  created_at: z.int().nullish(),
  data_source_type: z.string().nullish(),
  dataset_id: z.string().nullish(),
  dataset_name: z.string().nullish(),
  document_id: z.string().nullish(),
  document_name: z.string().nullish(),
  hit_count: z.int().nullish(),
  id: z.string().optional(),
  index_node_hash: z.string().nullish(),
  message_id: z.string().optional(),
  position: z.int(),
  score: z.number().nullish(),
  segment_id: z.string().nullish(),
  segment_position: z.int().nullish(),
  summary: z.string().nullish(),
  word_count: z.int().nullish(),
})

/**
 * SegmentAttachmentResponse
 */
export const zSegmentAttachmentResponse = z.object({
  extension: z.string(),
  id: z.string(),
  mime_type: z.string().nullable(),
  name: z.string(),
  size: z.int(),
  source_url: z.string(),
})

/**
 * SegmentCreateItemPayload
 */
export const zSegmentCreateItemPayload = z.object({
  answer: z.string().nullish(),
  attachment_ids: z.array(z.string()).nullish(),
  content: z.string().min(1),
  keywords: z.array(z.string()).nullish(),
})

/**
 * SegmentCreatePayload
 */
export const zSegmentCreatePayload = z.object({
  segments: z.array(zSegmentCreateItemPayload).min(1),
})

/**
 * SegmentListQuery
 */
export const zSegmentListQuery = z.object({
  keyword: z.string().nullish(),
  limit: z.int().gte(1).optional().default(20),
  page: z.int().gte(1).optional().default(1),
  status: z.array(z.string()).optional(),
})

/**
 * SegmentResponse
 */
export const zSegmentResponse = z.object({
  answer: z.string().nullable(),
  attachments: z.array(zSegmentAttachmentResponse),
  child_chunks: z.array(zChildChunkResponse),
  completed_at: z.int().nullable(),
  content: z.string(),
  created_at: z.int(),
  created_by: z.string(),
  disabled_at: z.int().nullable(),
  disabled_by: z.string().nullable(),
  document_id: z.string(),
  enabled: z.boolean(),
  error: z.string().nullable(),
  hit_count: z.int(),
  id: z.string(),
  index_node_hash: z.string().nullable(),
  index_node_id: z.string().nullable(),
  indexing_at: z.int().nullable(),
  keywords: z.array(z.string()).nullable(),
  position: z.int(),
  sign_content: z.string(),
  status: z.string(),
  stopped_at: z.int().nullable(),
  summary: z.string().nullable(),
  tokens: z.int(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  word_count: z.int(),
})

/**
 * SegmentCreateListResponse
 */
export const zSegmentCreateListResponse = z.object({
  data: z.array(zSegmentResponse),
  doc_form: z.string(),
})

/**
 * SegmentDetailResponse
 */
export const zSegmentDetailResponse = z.object({
  data: zSegmentResponse,
  doc_form: z.string(),
})

/**
 * SegmentListResponse
 */
export const zSegmentListResponse = z.object({
  data: z.array(zSegmentResponse),
  doc_form: z.string(),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * SegmentUpdateArgs
 */
export const zSegmentUpdateArgs = z.object({
  answer: z.string().nullish(),
  attachment_ids: z.array(z.string()).nullish(),
  content: z.string().nullish(),
  enabled: z.boolean().nullish(),
  keywords: z.array(z.string()).nullish(),
  regenerate_child_chunks: z.boolean().optional().default(false),
  summary: z.string().nullish(),
})

/**
 * SegmentUpdatePayload
 */
export const zSegmentUpdatePayload = z.object({
  segment: zSegmentUpdateArgs,
})

/**
 * Segmentation
 */
export const zSegmentation = z.object({
  chunk_overlap: z.int().optional().default(0),
  max_tokens: z.int(),
  separator: z.string().optional().default('\n'),
})

/**
 * Rule
 */
export const zRule = z.object({
  parent_mode: z.enum(['full-doc', 'paragraph']).nullish(),
  pre_processing_rules: z.array(zPreProcessingRule).nullish(),
  segmentation: zSegmentation.nullish(),
  subchunk_segmentation: zSegmentation.nullish(),
})

/**
 * ProcessRule
 */
export const zProcessRule = z.object({
  mode: zProcessRuleMode,
  rules: zRule.nullish(),
})

/**
 * SimpleAccount
 */
export const zSimpleAccount = z.object({
  email: z.string(),
  id: z.string(),
  name: z.string(),
})

/**
 * SimpleConversation
 */
export const zSimpleConversation = z.object({
  created_at: z.int().nullish(),
  id: z.string(),
  inputs: z.record(z.string(), zJsonValue),
  introduction: z.string().nullish(),
  name: z.string(),
  status: z.string(),
  updated_at: z.int().nullish(),
})

/**
 * ConversationInfiniteScrollPagination
 */
export const zConversationInfiniteScrollPagination = z.object({
  data: z.array(zSimpleConversation),
  has_more: z.boolean(),
  limit: z.int(),
})

/**
 * SimpleEndUser
 */
export const zSimpleEndUser = z.object({
  id: z.string(),
  is_anonymous: z.boolean(),
  session_id: z.string().nullish(),
  type: z.string(),
})

/**
 * SimpleFeedback
 */
export const zSimpleFeedback = z.object({
  rating: z.string().nullish(),
})

/**
 * SimpleResultResponse
 */
export const zSimpleResultResponse = z.object({
  result: z.string(),
})

/**
 * SimpleResultStringListResponse
 */
export const zSimpleResultStringListResponse = z.object({
  data: z.array(z.string()),
  result: z.string(),
})

/**
 * Site
 */
export const zSite = z.object({
  chat_color_theme: z.string().nullish(),
  chat_color_theme_inverted: z.boolean(),
  copyright: z.string().nullish(),
  custom_disclaimer: z.string().nullish(),
  default_language: z.string(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  icon_url: z.string().nullable(),
  privacy_policy: z.string().nullish(),
  show_workflow_steps: z.boolean(),
  title: z.string(),
  use_icon_as_answer_icon: z.boolean(),
})

/**
 * SystemParameters
 */
export const zSystemParameters = z.object({
  audio_file_size_limit: z.int(),
  file_size_limit: z.int(),
  image_file_size_limit: z.int(),
  video_file_size_limit: z.int(),
  workflow_file_upload_limit: z.int(),
})

/**
 * Parameters
 */
export const zParameters = z.object({
  annotation_reply: zJsonObject,
  file_upload: zJsonObject,
  more_like_this: zJsonObject,
  opening_statement: z.string().nullish(),
  retriever_resource: zJsonObject,
  sensitive_word_avoidance: zJsonObject,
  speech_to_text: zJsonObject,
  suggested_questions: z.array(z.string()),
  suggested_questions_after_answer: zJsonObject,
  system_parameters: zSystemParameters,
  text_to_speech: zJsonObject,
  user_input_form: z.array(zJsonObject),
})

/**
 * TagBindingPayload
 */
export const zTagBindingPayload = z.object({
  tag_ids: z.array(z.string()),
  target_id: z.string(),
})

/**
 * TagCreatePayload
 */
export const zTagCreatePayload = z.object({
  name: z.string().min(1).max(50),
})

/**
 * TagDeletePayload
 */
export const zTagDeletePayload = z.object({
  tag_id: z.string(),
})

/**
 * TagUnbindingPayload
 *
 * Accept the legacy single-tag Service API payload while exposing a normalized tag_ids list internally.
 */
export const zTagUnbindingPayload = z.object({
  tag_id: z.string().nullish(),
  tag_ids: z.array(z.string()).optional(),
  target_id: z.string(),
})

/**
 * TagUpdatePayload
 */
export const zTagUpdatePayload = z.object({
  name: z.string().min(1).max(50),
  tag_id: z.string(),
})

/**
 * TextToAudioPayload
 */
export const zTextToAudioPayload = z.object({
  message_id: z.string().nullish(),
  streaming: z.boolean().nullish(),
  text: z.string().nullish(),
  voice: z.string().nullish(),
})

/**
 * UrlResponse
 */
export const zUrlResponse = z.object({
  url: z.string(),
})

/**
 * UserActionConfig
 *
 * User action configuration.
 */
export const zUserActionConfig = z.object({
  button_style: zButtonStyle.optional().default('default'),
  id: z.string().max(20),
  title: z.string().max(100),
})

/**
 * ValueSourceType
 *
 * ValueSourceType records whether the value comes from a static setting
 * in form definiton, or a variable while the workflow is running.
 */
export const zValueSourceType = z.enum(['constant', 'variable'])

/**
 * StringListSource
 */
export const zStringListSource = z.object({
  selector: z.array(z.string()).optional(),
  type: zValueSourceType,
  value: z.array(z.string()).optional(),
})

/**
 * SelectInputConfig
 */
export const zSelectInputConfig = z.object({
  option_source: zStringListSource,
  output_variable_name: z.string(),
  type: z.literal('select').optional().default('select'),
})

/**
 * StringSource
 *
 * Default configuration for form inputs.
 */
export const zStringSource = z.object({
  selector: z.array(z.string()).optional(),
  type: zValueSourceType,
  value: z.string().optional().default(''),
})

/**
 * ParagraphInputConfig
 *
 * Form input definition.
 */
export const zParagraphInputConfig = z.object({
  default: zStringSource.nullish(),
  output_variable_name: z.string(),
  type: z.literal('paragraph').optional().default('paragraph'),
})

export const zFormInputConfig = z.discriminatedUnion('type', [
  zParagraphInputConfig.extend({ type: z.literal('paragraph') }),
  zSelectInputConfig.extend({ type: z.literal('select') }),
  zFileInputConfig.extend({ type: z.literal('file') }),
  zFileListInputConfig.extend({ type: z.literal('file-list') }),
])

/**
 * HumanInputFormDefinition
 */
export const zHumanInputFormDefinition = z.object({
  actions: z.array(zUserActionConfig).optional(),
  display_in_ui: z.boolean().optional().default(false),
  expiration_time: z.int(),
  form_content: z.string(),
  form_id: z.string(),
  form_token: z.string().nullish(),
  inputs: z.array(zFormInputConfig).optional(),
  node_id: z.string(),
  node_title: z.string(),
  resolved_default_values: z.record(z.string(), z.unknown()).optional(),
})

/**
 * HumanInputContent
 */
export const zHumanInputContent = z.object({
  form_definition: zHumanInputFormDefinition.nullish(),
  form_submission_data: zHumanInputFormSubmissionData.nullish(),
  submitted: z.boolean(),
  type: zExecutionContentType.optional().default('human_input'),
  workflow_run_id: z.string(),
})

/**
 * MessageListItem
 */
export const zMessageListItem = z.object({
  agent_thoughts: z.array(zAgentThought),
  answer: z.string(),
  conversation_id: z.string(),
  created_at: z.int().nullish(),
  error: z.string().nullish(),
  extra_contents: z.array(zHumanInputContent),
  feedback: zSimpleFeedback.nullish(),
  id: z.string(),
  inputs: z.record(z.string(), zJsonValueType),
  message_files: z.array(zMessageFile),
  parent_message_id: z.string().nullish(),
  query: z.string(),
  retriever_resources: z.array(zRetrieverResource),
  status: z.string(),
})

/**
 * MessageInfiniteScrollPagination
 */
export const zMessageInfiniteScrollPagination = z.object({
  data: z.array(zMessageListItem),
  has_more: z.boolean(),
  limit: z.int(),
})

/**
 * WeightKeywordSetting
 */
export const zWeightKeywordSetting = z.object({
  keyword_weight: z.number(),
})

/**
 * WeightVectorSetting
 */
export const zWeightVectorSetting = z.object({
  embedding_model_name: z.string(),
  embedding_provider_name: z.string(),
  vector_weight: z.number(),
})

/**
 * WeightModel
 */
export const zWeightModel = z.object({
  keyword_setting: zWeightKeywordSetting.nullish(),
  vector_setting: zWeightVectorSetting.nullish(),
  weight_type: z.enum(['customized', 'keyword_first', 'semantic_first']).nullish(),
})

/**
 * RetrievalModel
 */
export const zRetrievalModel = z.object({
  metadata_filtering_conditions: zMetadataFilteringCondition.nullish(),
  reranking_enable: z.boolean(),
  reranking_mode: z.string().nullish(),
  reranking_model: zRerankingModel.nullish(),
  score_threshold: z.number().nullish(),
  score_threshold_enabled: z.boolean(),
  search_method: zRetrievalMethod,
  top_k: z.int(),
  weights: zWeightModel.nullish(),
})

/**
 * DatasetCreatePayload
 */
export const zDatasetCreatePayload = z.object({
  description: z.string().max(400).optional().default(''),
  embedding_model: z.string().nullish(),
  embedding_model_provider: z.string().nullish(),
  external_knowledge_api_id: z.string().nullish(),
  external_knowledge_id: z.string().nullish(),
  indexing_technique: z.enum(['economy', 'high_quality']).nullish(),
  name: z.string().min(1).max(40),
  permission: zPermissionEnum.nullish().default('only_me'),
  provider: z.string().optional().default('vendor'),
  retrieval_model: zRetrievalModel.nullish(),
  summary_index_setting: z.record(z.string(), z.unknown()).nullish(),
})

/**
 * DatasetUpdatePayload
 */
export const zDatasetUpdatePayload = z.object({
  description: z.string().max(400).nullish(),
  embedding_model: z.string().nullish(),
  embedding_model_provider: z.string().nullish(),
  external_knowledge_api_id: z.string().nullish(),
  external_knowledge_id: z.string().nullish(),
  external_retrieval_model: z.record(z.string(), z.unknown()).nullish(),
  indexing_technique: z.enum(['economy', 'high_quality']).nullish(),
  name: z.string().min(1).max(40).nullish(),
  partial_member_list: z.array(z.record(z.string(), z.string())).nullish(),
  permission: zPermissionEnum.nullish(),
  retrieval_model: zRetrievalModel.nullish(),
})

/**
 * DocumentTextCreatePayload
 */
export const zDocumentTextCreatePayload = z.object({
  doc_form: z.string().optional().default('text_model'),
  doc_language: z.string().optional().default('English'),
  embedding_model: z.string().nullish(),
  embedding_model_provider: z.string().nullish(),
  indexing_technique: z.string().nullish(),
  name: z.string(),
  original_document_id: z.string().nullish(),
  process_rule: zProcessRule.nullish(),
  retrieval_model: zRetrievalModel.nullish(),
  text: z.string(),
})

/**
 * DocumentTextUpdate
 */
export const zDocumentTextUpdate = z.object({
  doc_form: z.string().optional().default('text_model'),
  doc_language: z.string().optional().default('English'),
  name: z.string().nullish(),
  process_rule: zProcessRule.nullish(),
  retrieval_model: zRetrievalModel.nullish(),
  text: z.string().nullish(),
})

/**
 * HitTestingPayload
 */
export const zHitTestingPayload = z.object({
  attachment_ids: z.array(z.string()).nullish(),
  external_retrieval_model: z.record(z.string(), z.unknown()).nullish(),
  query: z.string().max(250),
  retrieval_model: zRetrievalModel.nullish(),
})

/**
 * WorkflowEventsQuery
 */
export const zWorkflowEventsQuery = z.object({
  continue_on_pause: z.boolean().optional().default(false),
  include_state_snapshot: z.boolean().optional().default(false),
  user: z.string(),
})

/**
 * WorkflowLogQuery
 */
export const zWorkflowLogQuery = z.object({
  created_at__after: z.string().nullish(),
  created_at__before: z.string().nullish(),
  created_by_account: z.string().nullish(),
  created_by_end_user_session_id: z.string().nullish(),
  keyword: z.string().nullish(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  page: z.int().gte(1).lte(99999).optional().default(1),
  status: z.enum(['failed', 'stopped', 'succeeded']).nullish(),
})

/**
 * WorkflowRunForLogResponse
 */
export const zWorkflowRunForLogResponse = z.object({
  created_at: z.int().nullish(),
  elapsed_time: z.union([z.number(), z.int()]).nullish(),
  error: z.string().nullish(),
  exceptions_count: z.int().nullish(),
  finished_at: z.int().nullish(),
  id: z.string(),
  status: z.string().nullish(),
  total_steps: z.int().nullish(),
  total_tokens: z.int().nullish(),
  triggered_from: z.string().nullish(),
  version: z.string().nullish(),
})

/**
 * WorkflowAppLogPartialResponse
 */
export const zWorkflowAppLogPartialResponse = z.object({
  created_at: z.int().nullish(),
  created_by_account: zSimpleAccount.nullish(),
  created_by_end_user: zSimpleEndUser.nullish(),
  created_by_role: z.string().nullish(),
  created_from: z.string().nullish(),
  details: z
    .union([
      z.record(z.string(), z.unknown()),
      z.array(z.unknown()),
      z.string(),
      z.int(),
      z.number(),
      z.boolean(),
    ])
    .nullish(),
  id: z.string(),
  workflow_run: zWorkflowRunForLogResponse.nullish(),
})

/**
 * WorkflowAppLogPaginationResponse
 */
export const zWorkflowAppLogPaginationResponse = z.object({
  data: z.array(zWorkflowAppLogPartialResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * WorkflowRunPayload
 */
export const zWorkflowRunPayload = z.object({
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  inputs: z.record(z.string(), z.unknown()),
  response_mode: z.enum(['blocking', 'streaming']).nullish(),
  trace_session_id: z.string().nullish(),
})

/**
 * WorkflowRunResponse
 */
export const zWorkflowRunResponse = z.object({
  created_at: z.int().nullish(),
  elapsed_time: z.union([z.number(), z.int()]).nullish(),
  error: z.string().nullish(),
  finished_at: z.int().nullish(),
  id: z.string(),
  inputs: z
    .union([
      z.record(z.string(), z.unknown()),
      z.array(z.unknown()),
      z.string(),
      z.int(),
      z.number(),
      z.boolean(),
    ])
    .nullish(),
  outputs: z.record(z.string(), z.unknown()).optional(),
  status: z.string(),
  total_steps: z.int().nullish(),
  total_tokens: z.int().nullish(),
  workflow_id: z.string(),
})

/**
 * GeneratedAppResponse
 */
export const zGeneratedAppResponseWritable = zJsonValue

/**
 * HumanInputFormSubmitResponse
 */
export const zHumanInputFormSubmitResponseWritable = z.record(z.string(), z.never())

/**
 * Site
 */
export const zSiteWritable = z.object({
  chat_color_theme: z.string().nullish(),
  chat_color_theme_inverted: z.boolean(),
  copyright: z.string().nullish(),
  custom_disclaimer: z.string().nullish(),
  default_language: z.string(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  privacy_policy: z.string().nullish(),
  show_workflow_steps: z.boolean(),
  title: z.string(),
  use_icon_as_answer_icon: z.boolean(),
})

/**
 * Success
 */
export const zGetRootResponse = zIndexInfoResponse

export const zGetAppFeedbacksQuery = z.object({
  limit: z.int().gte(1).lte(101).optional().default(20),
  page: z.int().gte(1).optional().default(1),
})

/**
 * Feedbacks retrieved successfully
 */
export const zGetAppFeedbacksResponse = zAppFeedbackListResponse

export const zPostAppsAnnotationReplyByActionBody = zAnnotationReplyActionPayload

export const zPostAppsAnnotationReplyByActionPath = z.object({
  action: z.string(),
})

/**
 * Action completed successfully
 */
export const zPostAppsAnnotationReplyByActionResponse = zAnnotationJobStatusResponse

export const zGetAppsAnnotationReplyByActionStatusByJobIdPath = z.object({
  action: z.string(),
  job_id: z.string(),
})

/**
 * Job status retrieved successfully
 */
export const zGetAppsAnnotationReplyByActionStatusByJobIdResponse = zAnnotationJobStatusResponse

export const zGetAppsAnnotationsQuery = z.object({
  keyword: z.string().optional().default(''),
  limit: z.int().gte(1).optional().default(20),
  page: z.int().gte(1).optional().default(1),
})

/**
 * Annotations retrieved successfully
 */
export const zGetAppsAnnotationsResponse = zAnnotationList

export const zPostAppsAnnotationsBody = zAnnotationCreatePayload

/**
 * Annotation created successfully
 */
export const zPostAppsAnnotationsResponse = zAnnotation

export const zDeleteAppsAnnotationsByAnnotationIdPath = z.object({
  annotation_id: z.string(),
})

/**
 * Annotation deleted successfully
 */
export const zDeleteAppsAnnotationsByAnnotationIdResponse = z.void()

export const zPutAppsAnnotationsByAnnotationIdBody = zAnnotationCreatePayload

export const zPutAppsAnnotationsByAnnotationIdPath = z.object({
  annotation_id: z.string(),
})

/**
 * Annotation updated successfully
 */
export const zPutAppsAnnotationsByAnnotationIdResponse = zAnnotation

/**
 * Audio successfully transcribed
 */
export const zPostAudioToTextResponse = zAudioTranscriptResponse

export const zPostChatMessagesBody = zChatRequestPayload

/**
 * Message sent successfully
 */
export const zPostChatMessagesResponse = zGeneratedAppResponse

export const zPostChatMessagesByTaskIdStopPath = z.object({
  task_id: z.string(),
})

/**
 * Task stopped successfully
 */
export const zPostChatMessagesByTaskIdStopResponse = zSimpleResultResponse

export const zPostCompletionMessagesBody = zCompletionRequestPayload

/**
 * Completion created successfully
 */
export const zPostCompletionMessagesResponse = zGeneratedAppResponse

export const zPostCompletionMessagesByTaskIdStopPath = z.object({
  task_id: z.string(),
})

/**
 * Task stopped successfully
 */
export const zPostCompletionMessagesByTaskIdStopResponse = zSimpleResultResponse

export const zGetConversationsQuery = z.object({
  last_id: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  sort_by: z
    .enum(['-created_at', '-updated_at', 'created_at', 'updated_at'])
    .optional()
    .default('-updated_at'),
})

/**
 * Conversations retrieved successfully
 */
export const zGetConversationsResponse = zConversationInfiniteScrollPagination

export const zDeleteConversationsByCIdPath = z.object({
  c_id: z.string(),
})

/**
 * Conversation deleted successfully
 */
export const zDeleteConversationsByCIdResponse = z.void()

export const zPostConversationsByCIdNameBody = zConversationRenamePayload

export const zPostConversationsByCIdNamePath = z.object({
  c_id: z.string(),
})

/**
 * Conversation renamed successfully
 */
export const zPostConversationsByCIdNameResponse = zSimpleConversation

export const zGetConversationsByCIdVariablesPath = z.object({
  c_id: z.string(),
})

export const zGetConversationsByCIdVariablesQuery = z.object({
  last_id: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  variable_name: z.string().min(1).max(255).optional(),
})

/**
 * Variables retrieved successfully
 */
export const zGetConversationsByCIdVariablesResponse
  = zConversationVariableInfiniteScrollPaginationResponse

export const zPutConversationsByCIdVariablesByVariableIdBody = zConversationVariableUpdatePayload

export const zPutConversationsByCIdVariablesByVariableIdPath = z.object({
  c_id: z.string(),
  variable_id: z.string(),
})

/**
 * Variable updated successfully
 */
export const zPutConversationsByCIdVariablesByVariableIdResponse = zConversationVariableResponse

export const zGetDatasetsQuery = z.object({
  include_all: z.boolean().optional().default(false),
  keyword: z.string().optional(),
  limit: z.int().optional().default(20),
  page: z.int().optional().default(1),
  tag_ids: z.array(z.string()).optional(),
})

/**
 * Datasets retrieved successfully
 */
export const zGetDatasetsResponse = zDatasetListResponse

export const zPostDatasetsBody = zDatasetCreatePayload

/**
 * Dataset created successfully
 */
export const zPostDatasetsResponse = zDatasetDetailResponse

/**
 * File uploaded successfully
 */
export const zPostDatasetsPipelineFileUploadResponse = zPipelineUploadFileResponse

export const zDeleteDatasetsTagsBody = zTagDeletePayload

/**
 * Tag deleted successfully
 */
export const zDeleteDatasetsTagsResponse = z.void()

/**
 * Tags retrieved successfully
 */
export const zGetDatasetsTagsResponse = zKnowledgeTagListResponse

export const zPatchDatasetsTagsBody = zTagUpdatePayload

/**
 * Tag updated successfully
 */
export const zPatchDatasetsTagsResponse = zKnowledgeTagResponse

export const zPostDatasetsTagsBody = zTagCreatePayload

/**
 * Tag created successfully
 */
export const zPostDatasetsTagsResponse = zKnowledgeTagResponse

export const zPostDatasetsTagsBindingBody = zTagBindingPayload

/**
 * Tags bound successfully
 */
export const zPostDatasetsTagsBindingResponse = z.void()

export const zPostDatasetsTagsUnbindingBody = zTagUnbindingPayload

/**
 * Tags unbound successfully
 */
export const zPostDatasetsTagsUnbindingResponse = z.void()

export const zDeleteDatasetsByDatasetIdPath = z.object({
  dataset_id: z.string(),
})

/**
 * Dataset deleted successfully
 */
export const zDeleteDatasetsByDatasetIdResponse = z.void()

export const zGetDatasetsByDatasetIdPath = z.object({
  dataset_id: z.string(),
})

/**
 * Dataset retrieved successfully
 */
export const zGetDatasetsByDatasetIdResponse = zDatasetDetailWithPartialMembersResponse

export const zPatchDatasetsByDatasetIdBody = zDatasetUpdatePayload

export const zPatchDatasetsByDatasetIdPath = z.object({
  dataset_id: z.string(),
})

/**
 * Dataset updated successfully
 */
export const zPatchDatasetsByDatasetIdResponse = zDatasetDetailWithPartialMembersResponse

export const zPostDatasetsByDatasetIdDocumentCreateByFileBody = z.object({
  data: z.string().optional(),
  file: z.custom<Blob | File>(),
})

export const zPostDatasetsByDatasetIdDocumentCreateByFilePath = z.object({
  dataset_id: z.string(),
})

/**
 * Document created successfully
 */
export const zPostDatasetsByDatasetIdDocumentCreateByFileResponse = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdDocumentCreateByTextBody = zDocumentTextCreatePayload

export const zPostDatasetsByDatasetIdDocumentCreateByTextPath = z.object({
  dataset_id: z.string(),
})

/**
 * Document created successfully
 */
export const zPostDatasetsByDatasetIdDocumentCreateByTextResponse = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdDocumentCreateByFile2Body = z.object({
  data: z.string().optional(),
  file: z.custom<Blob | File>(),
})

export const zPostDatasetsByDatasetIdDocumentCreateByFile2Path = z.object({
  dataset_id: z.string(),
})

/**
 * Document created successfully
 */
export const zPostDatasetsByDatasetIdDocumentCreateByFile2Response = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdDocumentCreateByText2Body = zDocumentTextCreatePayload

export const zPostDatasetsByDatasetIdDocumentCreateByText2Path = z.object({
  dataset_id: z.string(),
})

/**
 * Document created successfully
 */
export const zPostDatasetsByDatasetIdDocumentCreateByText2Response = zDocumentAndBatchResponse

export const zGetDatasetsByDatasetIdDocumentsPath = z.object({
  dataset_id: z.string(),
})

export const zGetDatasetsByDatasetIdDocumentsQuery = z.object({
  keyword: z.string().optional(),
  limit: z.int().optional().default(20),
  page: z.int().optional().default(1),
  status: z.string().optional(),
})

/**
 * Documents retrieved successfully
 */
export const zGetDatasetsByDatasetIdDocumentsResponse = zDocumentListResponse

export const zPostDatasetsByDatasetIdDocumentsDownloadZipBody = zDocumentBatchDownloadZipPayload

export const zPostDatasetsByDatasetIdDocumentsDownloadZipPath = z.object({
  dataset_id: z.string(),
})

/**
 * ZIP archive generated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsDownloadZipResponse = zBinaryFileResponse

export const zPostDatasetsByDatasetIdDocumentsMetadataBody = zMetadataOperationData

export const zPostDatasetsByDatasetIdDocumentsMetadataPath = z.object({
  dataset_id: z.string(),
})

/**
 * Documents metadata updated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsMetadataResponse = zDatasetMetadataActionResponse

export const zPatchDatasetsByDatasetIdDocumentsStatusByActionBody = zDocumentStatusPayload

export const zPatchDatasetsByDatasetIdDocumentsStatusByActionPath = z.object({
  action: z.string(),
  dataset_id: z.string(),
})

/**
 * Document status updated successfully
 */
export const zPatchDatasetsByDatasetIdDocumentsStatusByActionResponse = zSimpleResultResponse

export const zGetDatasetsByDatasetIdDocumentsByBatchIndexingStatusPath = z.object({
  batch: z.string(),
  dataset_id: z.string(),
})

/**
 * Indexing status retrieved successfully
 */
export const zGetDatasetsByDatasetIdDocumentsByBatchIndexingStatusResponse
  = zDocumentStatusListResponse

export const zDeleteDatasetsByDatasetIdDocumentsByDocumentIdPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Document deleted successfully
 */
export const zDeleteDatasetsByDatasetIdDocumentsByDocumentIdResponse = z.void()

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdQuery = z.object({
  metadata: z.enum(['all', 'only', 'without']).optional().default('all'),
})

/**
 * Document retrieved successfully
 */
export const zGetDatasetsByDatasetIdDocumentsByDocumentIdResponse = zDocumentDetailResponse

export const zPatchDatasetsByDatasetIdDocumentsByDocumentIdBody = z.object({
  data: z.string().optional(),
  file: z.custom<Blob | File>().optional(),
})

export const zPatchDatasetsByDatasetIdDocumentsByDocumentIdPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Document updated successfully
 */
export const zPatchDatasetsByDatasetIdDocumentsByDocumentIdResponse = zDocumentAndBatchResponse

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdDownloadPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Download URL generated successfully
 */
export const zGetDatasetsByDatasetIdDocumentsByDocumentIdDownloadResponse = zUrlResponse

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsQuery = z.object({
  keyword: z.string().optional(),
  limit: z.int().gte(1).optional().default(20),
  page: z.int().gte(1).optional().default(1),
  status: z.array(z.string()).optional(),
})

/**
 * Segments retrieved successfully
 */
export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsResponse = zSegmentListResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBody = zSegmentCreatePayload

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Segments created successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsResponse
  = zSegmentCreateListResponse

export const zDeleteDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
  segment_id: z.string(),
})

/**
 * Segment deleted successfully
 */
export const zDeleteDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdResponse = z.void()

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
  segment_id: z.string(),
})

/**
 * Segment retrieved successfully
 */
export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdResponse
  = zSegmentDetailResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdBody
  = zSegmentUpdatePayload

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
  segment_id: z.string(),
})

/**
 * Segment updated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdResponse
  = zSegmentDetailResponse

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksPath
  = z.object({
    dataset_id: z.string(),
    document_id: z.string(),
    segment_id: z.string(),
  })

export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksQuery
  = z.object({
    keyword: z.string().optional(),
    limit: z.int().gte(1).optional().default(20),
    page: z.int().gte(1).optional().default(1),
  })

/**
 * Child chunks retrieved successfully
 */
export const zGetDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksResponse
  = zChildChunkListResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksBody
  = zChildChunkCreatePayload

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksPath
  = z.object({
    dataset_id: z.string(),
    document_id: z.string(),
    segment_id: z.string(),
  })

/**
 * Child chunk created successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksResponse
  = zChildChunkDetailResponse

export const zDeleteDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksByChildChunkIdPath
  = z.object({
    child_chunk_id: z.string(),
    dataset_id: z.string(),
    document_id: z.string(),
    segment_id: z.string(),
  })

/**
 * Child chunk deleted successfully
 */
export const zDeleteDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksByChildChunkIdResponse
  = z.void()

export const zPatchDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksByChildChunkIdBody
  = zChildChunkUpdatePayload

export const zPatchDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksByChildChunkIdPath
  = z.object({
    child_chunk_id: z.string(),
    dataset_id: z.string(),
    document_id: z.string(),
    segment_id: z.string(),
  })

/**
 * Child chunk updated successfully
 */
export const zPatchDatasetsByDatasetIdDocumentsByDocumentIdSegmentsBySegmentIdChildChunksByChildChunkIdResponse
  = zChildChunkDetailResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByFileBody = z.object({
  data: z.string().optional(),
  file: z.custom<Blob | File>().optional(),
})

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByFilePath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Document updated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByFileResponse
  = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByTextBody = zDocumentTextUpdate

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByTextPath = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Document updated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByTextResponse
  = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByFile2Body = z.object({
  data: z.string().optional(),
  file: z.custom<Blob | File>().optional(),
})

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByFile2Path = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Document updated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByFile2Response
  = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByText2Body = zDocumentTextUpdate

export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByText2Path = z.object({
  dataset_id: z.string(),
  document_id: z.string(),
})

/**
 * Document updated successfully
 */
export const zPostDatasetsByDatasetIdDocumentsByDocumentIdUpdateByText2Response
  = zDocumentAndBatchResponse

export const zPostDatasetsByDatasetIdHitTestingBody = zHitTestingPayload

export const zPostDatasetsByDatasetIdHitTestingPath = z.object({
  dataset_id: z.string(),
})

/**
 * Hit testing results
 */
export const zPostDatasetsByDatasetIdHitTestingResponse = zHitTestingResponse

export const zGetDatasetsByDatasetIdMetadataPath = z.object({
  dataset_id: z.string(),
})

/**
 * Metadata retrieved successfully
 */
export const zGetDatasetsByDatasetIdMetadataResponse = zDatasetMetadataListResponse

export const zPostDatasetsByDatasetIdMetadataBody = zMetadataArgs

export const zPostDatasetsByDatasetIdMetadataPath = z.object({
  dataset_id: z.string(),
})

/**
 * Metadata created successfully
 */
export const zPostDatasetsByDatasetIdMetadataResponse = zDatasetMetadataResponse

export const zGetDatasetsByDatasetIdMetadataBuiltInPath = z.object({
  dataset_id: z.string(),
})

/**
 * Built-in fields retrieved successfully
 */
export const zGetDatasetsByDatasetIdMetadataBuiltInResponse = zDatasetMetadataBuiltInFieldsResponse

export const zPostDatasetsByDatasetIdMetadataBuiltInByActionPath = z.object({
  action: z.string(),
  dataset_id: z.string(),
})

/**
 * Action completed successfully
 */
export const zPostDatasetsByDatasetIdMetadataBuiltInByActionResponse
  = zDatasetMetadataActionResponse

export const zDeleteDatasetsByDatasetIdMetadataByMetadataIdPath = z.object({
  dataset_id: z.string(),
  metadata_id: z.string(),
})

/**
 * Metadata deleted successfully
 */
export const zDeleteDatasetsByDatasetIdMetadataByMetadataIdResponse = z.void()

export const zPatchDatasetsByDatasetIdMetadataByMetadataIdBody = zMetadataUpdatePayload

export const zPatchDatasetsByDatasetIdMetadataByMetadataIdPath = z.object({
  dataset_id: z.string(),
  metadata_id: z.string(),
})

/**
 * Metadata updated successfully
 */
export const zPatchDatasetsByDatasetIdMetadataByMetadataIdResponse = zDatasetMetadataResponse

export const zGetDatasetsByDatasetIdPipelineDatasourcePluginsPath = z.object({
  dataset_id: z.string(),
})

export const zGetDatasetsByDatasetIdPipelineDatasourcePluginsQuery = z.object({
  is_published: z.boolean().optional().default(true),
})

/**
 * Datasource plugins retrieved successfully
 */
export const zGetDatasetsByDatasetIdPipelineDatasourcePluginsResponse
  = zDatasourcePluginListResponse

export const zPostDatasetsByDatasetIdPipelineDatasourceNodesByNodeIdRunBody
  = zDatasourceNodeRunPayload

export const zPostDatasetsByDatasetIdPipelineDatasourceNodesByNodeIdRunPath = z.object({
  dataset_id: z.string(),
  node_id: z.string(),
})

/**
 * Datasource node run successfully
 */
export const zPostDatasetsByDatasetIdPipelineDatasourceNodesByNodeIdRunResponse
  = zGeneratedAppResponse

export const zPostDatasetsByDatasetIdPipelineRunBody = zPipelineRunApiEntity

export const zPostDatasetsByDatasetIdPipelineRunPath = z.object({
  dataset_id: z.string(),
})

/**
 * Pipeline run successfully
 */
export const zPostDatasetsByDatasetIdPipelineRunResponse = zGeneratedAppResponse

export const zPostDatasetsByDatasetIdRetrieveBody = zHitTestingPayload

export const zPostDatasetsByDatasetIdRetrievePath = z.object({
  dataset_id: z.string(),
})

/**
 * Hit testing results
 */
export const zPostDatasetsByDatasetIdRetrieveResponse = zHitTestingResponse

export const zGetDatasetsByDatasetIdTagsPath = z.object({
  dataset_id: z.string(),
})

/**
 * Tags retrieved successfully
 */
export const zGetDatasetsByDatasetIdTagsResponse = zDatasetBoundTagListResponse

export const zGetEndUsersByEndUserIdPath = z.object({
  end_user_id: z.string(),
})

/**
 * End user retrieved successfully
 */
export const zGetEndUsersByEndUserIdResponse = zEndUserDetail

/**
 * File uploaded successfully
 */
export const zPostFilesUploadResponse = zFileResponse

export const zGetFilesByFileIdPreviewPath = z.object({
  file_id: z.string(),
})

export const zGetFilesByFileIdPreviewQuery = z.object({
  as_attachment: z.boolean().optional().default(false),
})

/**
 * File retrieved successfully
 */
export const zGetFilesByFileIdPreviewResponse = zBinaryFileResponse

export const zGetFormHumanInputByFormTokenPath = z.object({
  form_token: z.string(),
})

/**
 * Form retrieved successfully
 */
export const zGetFormHumanInputByFormTokenResponse = zHumanInputFormDefinitionResponse

export const zPostFormHumanInputByFormTokenBody = zHumanInputFormSubmitPayload

export const zPostFormHumanInputByFormTokenPath = z.object({
  form_token: z.string(),
})

/**
 * Form submitted successfully
 */
export const zPostFormHumanInputByFormTokenResponse = zHumanInputFormSubmitResponse

/**
 * Application info retrieved successfully
 */
export const zGetInfoResponse = zAppInfoResponse

export const zGetMessagesQuery = z.object({
  conversation_id: z.string(),
  first_id: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
})

/**
 * Messages retrieved successfully
 */
export const zGetMessagesResponse = zMessageInfiniteScrollPagination

export const zPostMessagesByMessageIdFeedbacksBody = zMessageFeedbackPayload

export const zPostMessagesByMessageIdFeedbacksPath = z.object({
  message_id: z.string(),
})

/**
 * Feedback submitted successfully
 */
export const zPostMessagesByMessageIdFeedbacksResponse = zResultResponse

export const zGetMessagesByMessageIdSuggestedPath = z.object({
  message_id: z.string(),
})

/**
 * Suggested questions retrieved successfully
 */
export const zGetMessagesByMessageIdSuggestedResponse = zSimpleResultStringListResponse

/**
 * Metadata retrieved successfully
 */
export const zGetMetaResponse = zAppMetaResponse

/**
 * Parameters retrieved successfully
 */
export const zGetParametersResponse = zParameters

/**
 * Site configuration retrieved successfully
 */
export const zGetSiteResponse = zSite

export const zPostTextToAudioBody = zTextToAudioPayload

/**
 * Text successfully converted to audio
 */
export const zPostTextToAudioResponse = zAudioBinaryResponse

export const zGetWorkflowByTaskIdEventsPath = z.object({
  task_id: z.string(),
})

export const zGetWorkflowByTaskIdEventsQuery = z.object({
  continue_on_pause: z.boolean().optional().default(false),
  include_state_snapshot: z.boolean().optional().default(false),
  user: z.string(),
})

/**
 * SSE event stream
 */
export const zGetWorkflowByTaskIdEventsResponse = zEventStreamResponse

export const zGetWorkflowsLogsQuery = z.object({
  created_at__after: z.string().optional(),
  created_at__before: z.string().optional(),
  created_by_account: z.string().optional(),
  created_by_end_user_session_id: z.string().optional(),
  keyword: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  page: z.int().gte(1).lte(99999).optional().default(1),
  status: z.enum(['failed', 'stopped', 'succeeded']).optional(),
})

/**
 * Logs retrieved successfully
 */
export const zGetWorkflowsLogsResponse = zWorkflowAppLogPaginationResponse

export const zPostWorkflowsRunBody = zWorkflowRunPayload

/**
 * Workflow executed successfully
 */
export const zPostWorkflowsRunResponse = zGeneratedAppResponse

export const zGetWorkflowsRunByWorkflowRunIdPath = z.object({
  workflow_run_id: z.string(),
})

/**
 * Workflow run details retrieved successfully
 */
export const zGetWorkflowsRunByWorkflowRunIdResponse = zWorkflowRunResponse

export const zPostWorkflowsTasksByTaskIdStopPath = z.object({
  task_id: z.string(),
})

/**
 * Task stopped successfully
 */
export const zPostWorkflowsTasksByTaskIdStopResponse = zSimpleResultResponse

export const zPostWorkflowsByWorkflowIdRunBody = zWorkflowRunPayload

export const zPostWorkflowsByWorkflowIdRunPath = z.object({
  workflow_id: z.string(),
})

/**
 * Workflow executed successfully
 */
export const zPostWorkflowsByWorkflowIdRunResponse = zGeneratedAppResponse

export const zGetWorkspacesCurrentModelsModelTypesByModelTypePath = z.object({
  model_type: z.string(),
})

/**
 * Models retrieved successfully
 */
export const zGetWorkspacesCurrentModelsModelTypesByModelTypeResponse
  = zProviderWithModelsListResponse