dify/packages/contracts/generated/api/console/dify-builder/zod.gen.ts

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

import * as z from 'zod'

/**
 * DifyBuilderSubmitActionPayload
 */
export const zDifyBuilderSubmitActionPayload = z.object({
  action_id: z.string().min(1),
  base_app_revision: z.string().min(1),
  base_version: z.int(),
  payload: z.record(z.string(), z.unknown()).optional(),
})

/**
 * DifyBuilderSubmitMessagePayload
 */
export const zDifyBuilderSubmitMessagePayload = z.object({
  base_version: z.int(),
  client_turn_id: z.string().min(1).max(128),
  text: z.string().min(1),
})

/**
 * BuilderErrorCode
 *
 * Stable HTTP error codes returned by the Builder console routes.
 */
export const zBuilderErrorCode = z.enum([
  'bad_request',
  'conflict',
  'feature_unavailable',
  'model_unavailable',
  'not_found',
  'session_busy',
])

/**
 * DifyBuilderErrorResponse
 */
export const zDifyBuilderErrorResponse = z.object({
  code: zBuilderErrorCode,
  message: z.string().nullish(),
  recoverable: z.boolean().nullish(),
})

/**
 * AppRevision
 */
export const zAppRevision = z.object({
  conflicted: z.boolean(),
  current: z.string(),
  observed: z.string(),
})

/**
 * CheckpointRef
 */
export const zCheckpointRef = z.object({
  checkpoint_id: z.string(),
  created_at: z.string(),
  label: z.string(),
})

/**
 * EntryMode
 */
export const zEntryMode = z.enum(['build', 'edit', 'fix', 'fix_checklist'])

/**
 * SessionModel
 */
export const zSessionModel = z.object({
  completion_params: z.record(z.string(), z.unknown()).optional(),
  mode: z.string().optional().default(''),
  name: z.string(),
  provider: z.string(),
})

/**
 * DifyBuilderCreateBuildSessionPayload
 */
export const zDifyBuilderCreateBuildSessionPayload = z.object({
  app_id: z.string().min(1),
  derive_app_name: z.boolean().optional().default(false),
  goal_text: z.string().min(1),
  model_config: zSessionModel.nullish(),
  scenario: z.literal('build'),
})

/**
 * DifyBuilderCreateEditSessionPayload
 */
export const zDifyBuilderCreateEditSessionPayload = z.object({
  app_id: z.string().min(1),
  goal_text: z.string().min(1),
  model_config: zSessionModel.nullish(),
  scenario: z.literal('edit'),
})

/**
 * DifyBuilderCreateFixSessionPayload
 */
export const zDifyBuilderCreateFixSessionPayload = z.object({
  app_id: z.string().min(1),
  failed_run_id: z.string().min(1),
  model_config: zSessionModel.nullish(),
  scenario: z.literal('fix'),
})

/**
 * Phase
 *
 * Coarse UX phase shown in the panel header (spec §2).
 */
export const zPhase = z.enum([
  'clarify',
  'complete',
  'modify',
  'plan',
  'publish',
  'resources',
  'review',
  'test',
  'understand',
])

/**
 * RecoveryRef
 */
export const zRecoveryRef = z.object({
  can_continue: z.boolean(),
  can_restart: z.boolean(),
  message: z.string(),
  recovery_class: z.string(),
})

/**
 * RunStatus
 *
 * Widened run-status vocabulary (spec §2).
 *
 * ``processing`` => ``canvas_read_only = true`` (WORKING).
 * ``waiting_*``/``paused`` => editable (WAITING).
 * ``complete``/``failed`` => terminal.
 */
export const zRunStatus = z.enum([
  'complete',
  'failed',
  'paused',
  'processing',
  'waiting_confirmation',
  'waiting_input',
])

/**
 * DifyBuilderChecklistErrorPayload
 */
export const zDifyBuilderChecklistErrorPayload = z.object({
  messages: z.array(z.string()),
  node_id: z.string(),
  node_type: z.string(),
  plugin_missing: z.boolean(),
  title: z.string(),
  unconnected: z.boolean(),
})

/**
 * DifyBuilderCreateChecklistFixSessionPayload
 */
export const zDifyBuilderCreateChecklistFixSessionPayload = z.object({
  app_id: z.string().min(1),
  checklist_errors: z.array(zDifyBuilderChecklistErrorPayload).min(1),
  failed_run_id: z.string().min(1).nullish(),
  model_config: zSessionModel.nullish(),
  scenario: z.literal('fix'),
})

/**
 * DifyBuilderCreateSessionPayload
 *
 * Create a Build, Edit, failed-run Fix, or checklist Fix session.
 */
export const zDifyBuilderCreateSessionPayload = z.union([
  zDifyBuilderCreateBuildSessionPayload,
  zDifyBuilderCreateEditSessionPayload,
  zDifyBuilderCreateFixSessionPayload,
  zDifyBuilderCreateChecklistFixSessionPayload,
])

/**
 * AgentMessageEventData
 */
export const zAgentMessageEventData = z.object({
  answer: z.string(),
  at_version: z.int(),
  id: z.string(),
  kind: z.literal('agent_message').optional().default('agent_message'),
  operation_id: z.string(),
  revision: z.int(),
  seq: z.int(),
  session_id: z.string(),
  stage_id: z.string(),
})

/**
 * DifyBuilderAgentMessageEventResponse
 */
export const zDifyBuilderAgentMessageEventResponse = z.object({
  data: zAgentMessageEventData,
  event: z.literal('agent_message'),
})

/**
 * ReasoningEventData
 */
export const zReasoningEventData = z.object({
  at_version: z.int(),
  delta: z.string(),
  kind: z.literal('reasoning').optional().default('reasoning'),
  operation_id: z.string(),
  revision: z.int(),
  session_id: z.string(),
  span_id: z.string(),
  stage_id: z.string(),
})

/**
 * DifyBuilderReasoningEventResponse
 */
export const zDifyBuilderReasoningEventResponse = z.object({
  data: zReasoningEventData,
  event: z.literal('reasoning'),
})

/**
 * ErrorEventData
 */
export const zErrorEventData = z.object({
  code: z.string().nullish(),
  error: z.string(),
  kind: z.literal('error').optional().default('error'),
  message: z.string().nullish(),
  recoverable: z.boolean().nullish(),
})

/**
 * DifyBuilderErrorEventResponse
 */
export const zDifyBuilderErrorEventResponse = z.object({
  data: zErrorEventData,
  event: z.literal('error'),
})

/**
 * ActionKind
 *
 * Action button styling / semantics (spec §2, §5).
 *
 * ``automatic`` actions are not buttons — the client must not render
 * them; the server auto-advances. They exist in the stream only so the
 * FE can show "auto-continuing...".
 */
export const zActionKind = z.enum(['automatic', 'destructive', 'primary', 'secondary'])

/**
 * Action
 */
export const zAction = z.object({
  canvas_event: z.string().nullish(),
  id: z.string(),
  kind: zActionKind,
  label: z.string(),
  next_state: z.string().nullish(),
})

/**
 * UserItem
 */
export const zUserItem = z.object({
  text: z.string(),
  turn_id: z.string(),
})

/**
 * DifyBuilderUserConversationItemResponse
 */
export const zDifyBuilderUserConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('user'),
  payload: zUserItem,
  seq: z.int(),
})

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

/**
 * DifyBuilderDecisionConversationItemResponse
 */
export const zDifyBuilderDecisionConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('decision'),
  payload: zDecisionItem,
  seq: z.int(),
})

/**
 * NoticeItem
 */
export const zNoticeItem = z.object({
  text: z.string(),
  tone: z.string().optional().default('neutral'),
})

/**
 * DifyBuilderNoticeConversationItemResponse
 */
export const zDifyBuilderNoticeConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('notice'),
  payload: zNoticeItem,
  seq: z.int(),
})

/**
 * RunContextCard
 */
export const zRunContextCard = z.object({
  error_code: z.string(),
  message: z.string(),
  run_id: z.string(),
  title: z.string(),
  trace_ref: z.string().optional().default(''),
})

/**
 * DifyBuilderRunContextConversationItemResponse
 */
export const zDifyBuilderRunContextConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('run_context'),
  payload: zRunContextCard,
  seq: z.int(),
})

/**
 * PlanCard
 */
export const zPlanCard = z.object({
  items: z.array(z.string()).optional(),
  subtitle: z.string().nullish(),
  title: z.string(),
  version_tag: z.string(),
})

/**
 * DifyBuilderPlanConversationItemResponse
 */
export const zDifyBuilderPlanConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('plan'),
  payload: zPlanCard,
  seq: z.int(),
})

/**
 * ChallengeCard
 */
export const zChallengeCard = z.object({
  body: z.string(),
  title: z.string(),
  tone: z.string().optional().default('warning'),
})

/**
 * DifyBuilderChallengeConversationItemResponse
 */
export const zDifyBuilderChallengeConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('challenge'),
  payload: zChallengeCard,
  seq: z.int(),
})

/**
 * CheckpointCard
 */
export const zCheckpointCard = z.object({
  checkpoint_id: z.string(),
  created_at: z.string(),
  label: z.string(),
})

/**
 * DifyBuilderCheckpointConversationItemResponse
 */
export const zDifyBuilderCheckpointConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('checkpoint'),
  payload: zCheckpointCard,
  seq: z.int(),
})

/**
 * ErrorCard
 */
export const zErrorCard = z.object({
  body: z.string(),
  diagnostics: z.array(z.record(z.string(), z.unknown())).optional(),
  node_id: z.string().nullish(),
  title: z.string(),
  tone: z.string().optional().default('danger'),
})

/**
 * DifyBuilderErrorConversationItemResponse
 */
export const zDifyBuilderErrorConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('error'),
  payload: zErrorCard,
  seq: z.int(),
})

/**
 * PublishCard
 */
export const zPublishCard = z.object({
  badge: z.string().optional().default('live'),
  version: z.string(),
})

/**
 * DifyBuilderPublishConversationItemResponse
 */
export const zDifyBuilderPublishConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('publish'),
  payload: zPublishCard,
  seq: z.int(),
})

/**
 * BuildLearningCard
 */
export const zBuildLearningCard = z.object({
  policy: z.string(),
  state: z.string(),
})

/**
 * DifyBuilderBuildLearningConversationItemResponse
 */
export const zDifyBuilderBuildLearningConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('build_learning'),
  payload: zBuildLearningCard,
  seq: z.int(),
})

/**
 * WorkflowStreamAudio
 */
export const zWorkflowStreamAudio = z.object({
  audio: z.string(),
  audio_type: z.string().nullish(),
  event: z.enum(['tts_message', 'tts_message_end']),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * WorkflowStreamMessage
 */
export const zWorkflowStreamMessage = z.object({
  answer: z.string(),
  event: z.literal('message'),
  from_variable_selector: z.array(z.string()).optional(),
  id: z.string(),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * WorkflowStreamMessageEnd
 */
export const zWorkflowStreamMessageEnd = z.object({
  event: z.literal('message_end'),
  files: z.array(z.record(z.string(), z.unknown())).optional(),
  id: z.string(),
  metadata: z.record(z.string(), z.unknown()).optional(),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * WorkflowStreamMessageFile
 */
export const zWorkflowStreamMessageFile = z.object({
  belongs_to: z.string(),
  event: z.literal('message_file'),
  id: z.string(),
  task_id: z.string(),
  type: z.string(),
  url: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * WorkflowStreamMessageReplace
 */
export const zWorkflowStreamMessageReplace = z.object({
  answer: z.string(),
  event: z.literal('message_replace'),
  reason: z.string(),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * WorkflowStreamError
 */
export const zWorkflowStreamError = z.object({
  code: z.string(),
  event: z.literal('error'),
  message: z.string(),
  status: z.int(),
  workflow_run_id: z.string().nullish(),
})

/**
 * CanvasEdge
 */
export const zCanvasEdge = z.object({
  source: z.string(),
  target: z.string(),
})

/**
 * CanvasEvent
 *
 * Granular canvas-mutation signals (spec §6).
 *
 * Exactly 22 members, snake_cased from the mock's ``DifyBuilderCanvasEvent``
 * union. Presentation of committed backend state: replaying these from a
 * snapshot must reconstruct the same canvas.
 */
export const zCanvasEvent = z.enum([
  'add_knowledge_node',
  'add_llm_node',
  'add_output_node',
  'add_start_node',
  'apply_edit_plan',
  'apply_error_fix',
  'apply_preflight_fix',
  'cancel_publish',
  'create_checkpoint',
  'focus_checklist_node',
  'focus_error_node',
  'focus_workflow',
  'highlight_edit_target',
  'mark_repair_applied',
  'mark_review_ready',
  'mark_test_error',
  'mark_test_success',
  'publish_workflow',
  'reset_build_canvas',
  'revert_checkpoint',
  'start_retest',
  'start_test_run',
])

/**
 * CanvasEventData
 */
export const zCanvasEventData = z.object({
  at_version: z.int(),
  dify_run_id: z.string().optional().default(''),
  edge: zCanvasEdge.nullish(),
  event: zCanvasEvent,
  kind: z.literal('canvas').optional().default('canvas'),
  node_id: z.string().nullish(),
  operation_id: z.string(),
  revision: z.int(),
  session_id: z.string(),
  stage_id: z.string(),
})

/**
 * DifyBuilderCanvasEventResponse
 */
export const zDifyBuilderCanvasEventResponse = z.object({
  data: zCanvasEventData,
  event: z.literal('canvas'),
})

/**
 * OptionInput
 */
export const zOptionInput = z.object({
  max_length: z.int().optional().default(100),
  min_length: z.int().optional().default(0),
  placeholder: z.string().optional().default(''),
  required: z.boolean().optional().default(true),
})

/**
 * CardOption
 */
export const zCardOption = z.object({
  canvas_event: z.string().nullish(),
  description: z.string().optional().default(''),
  id: z.string(),
  input: zOptionInput.nullish(),
  is_default: z.boolean().optional().default(false),
  label: z.string(),
  next_state: z.string().nullish(),
  tone: z.string().optional().default('neutral'),
})

/**
 * Decision
 */
export const zDecision = z.object({
  cancel: zAction.nullish(),
  confirm: zAction.nullish(),
  default_option_id: z.string().optional().default(''),
  options: z.array(zCardOption).optional(),
})

/**
 * PreflightIssue
 */
export const zPreflightIssue = z.object({
  kind: z.string(),
  label: z.string(),
  node_id: z.string(),
})

/**
 * PreflightContextCard
 */
export const zPreflightContextCard = z.object({
  issue_count: z.int(),
  issues: z.array(zPreflightIssue).optional(),
  node_count: z.int(),
})

/**
 * DifyBuilderPreflightContextConversationItemResponse
 */
export const zDifyBuilderPreflightContextConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('preflight_context'),
  payload: zPreflightContextCard,
  seq: z.int(),
})

/**
 * FormField
 */
export const zFormField = z.object({
  allowed_file_extensions: z.array(z.string()).optional(),
  allowed_file_types: z.array(z.string()).optional(),
  allowed_file_upload_methods: z.array(z.string()).optional(),
  default: z.union([z.string(), z.int(), z.number(), z.boolean()]).nullish(),
  hint: z.string().nullish(),
  json_schema: z.union([z.string(), z.record(z.string(), z.unknown())]).nullish(),
  key: z.string(),
  label: z.string(),
  max_length: z.int().nullish(),
  number_limits: z.int().nullish(),
  options: z.array(z.string()).optional(),
  placeholder: z.string().nullish(),
  required: z.boolean().optional().default(false),
  type: z.string(),
  unit: z.string().nullish(),
})

/**
 * FormCard
 */
export const zFormCard = z.object({
  fields: z.array(zFormField).optional(),
  frozen: z.boolean().optional().default(false),
  values: z.record(z.string(), z.unknown()).optional(),
  variant: z.string(),
})

/**
 * DifyBuilderFormConversationItemResponse
 */
export const zDifyBuilderFormConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('form'),
  payload: zFormCard,
  seq: z.int(),
})

/**
 * ResourceOption
 */
export const zResourceOption = z.object({
  id: z.string(),
  kind: z.string(),
  label: z.string(),
  meta: z.string(),
  readiness: z.string(),
})

/**
 * ResourceSelectCard
 */
export const zResourceSelectCard = z.object({
  recommended: z.array(zResourceOption).optional(),
})

/**
 * DifyBuilderResourceSelectConversationItemResponse
 */
export const zDifyBuilderResourceSelectConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('resource_select'),
  payload: zResourceSelectCard,
  seq: z.int(),
})

/**
 * ChangedNode
 */
export const zChangedNode = z.object({
  node_id: z.string(),
  title: z.string().optional().default(''),
})

/**
 * ChangeSetCard
 */
export const zChangeSetCard = z.object({
  changes: z.array(z.string()),
  count: z.int(),
  nodes: z.array(zChangedNode).optional(),
  scope: z.string(),
})

/**
 * DifyBuilderChangeSetConversationItemResponse
 */
export const zDifyBuilderChangeSetConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('change_set'),
  payload: zChangeSetCard,
  seq: z.int(),
})

/**
 * TestStat
 */
export const zTestStat = z.object({
  label: z.string(),
  value: z.string(),
})

/**
 * TestResultCard
 */
export const zTestResultCard = z.object({
  dify_run_id: z.string().optional().default(''),
  output: z.string().optional().default(''),
  run_ids: z.array(z.string()).optional(),
  stats: z.array(zTestStat).optional(),
  subtitle: z.string(),
  title: z.string(),
  tone: z.string(),
})

/**
 * DifyBuilderTestResultConversationItemResponse
 */
export const zDifyBuilderTestResultConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('test_result'),
  payload: zTestResultCard,
  seq: z.int(),
})

/**
 * SummaryRow
 */
export const zSummaryRow = z.object({
  label: z.string(),
  value: z.string(),
})

/**
 * SummaryCard
 */
export const zSummaryCard = z.object({
  items: z.array(z.string()).optional(),
  rows: z.array(zSummaryRow).optional(),
  title: z.string().nullish(),
  variant: z.string(),
})

/**
 * DifyBuilderSummaryConversationItemResponse
 */
export const zDifyBuilderSummaryConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('summary'),
  payload: zSummaryCard,
  seq: z.int(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesIterationNodeStartStreamResponseData = z.object({
  created_at: z.int(),
  extras: z.record(z.string(), z.unknown()).optional(),
  id: z.string(),
  inputs: z.record(z.string(), z.unknown()).optional().default({}),
  inputs_truncated: z.boolean().optional().default(false),
  metadata: z.record(z.string(), z.unknown()).optional().default({}),
  node_id: z.string(),
  node_type: z.string(),
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['iteration_started'], IterationNodeStartStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralIterationStartedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesIterationNodeStartStreamResponseData,
  event: z.literal('iteration_started'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesIterationNodeNextStreamResponseData = z.object({
  created_at: z.int(),
  extras: z.record(z.string(), z.unknown()).optional(),
  id: z.string(),
  index: z.int(),
  node_id: z.string(),
  node_type: z.string(),
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['iteration_next'], IterationNodeNextStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralIterationNextData = z.object({
  data: zCoreAppEntitiesTaskEntitiesIterationNodeNextStreamResponseData,
  event: z.literal('iteration_next'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesLoopNodeStartStreamResponseData = z.object({
  created_at: z.int(),
  extras: z.record(z.string(), z.unknown()).optional(),
  id: z.string(),
  inputs: z.record(z.string(), z.unknown()).optional().default({}),
  inputs_truncated: z.boolean().optional().default(false),
  metadata: z.record(z.string(), z.unknown()).optional().default({}),
  node_id: z.string(),
  node_type: z.string(),
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['loop_started'], LoopNodeStartStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralLoopStartedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesLoopNodeStartStreamResponseData,
  event: z.literal('loop_started'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesLoopNodeNextStreamResponseData = z.object({
  created_at: z.int(),
  extras: z.record(z.string(), z.unknown()).optional(),
  id: z.string(),
  index: z.int(),
  node_id: z.string(),
  node_type: z.string(),
  pre_loop_output: z.unknown().optional(),
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['loop_next'], LoopNodeNextStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralLoopNextData = z.object({
  data: zCoreAppEntitiesTaskEntitiesLoopNodeNextStreamResponseData,
  event: z.literal('loop_next'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesTextChunkStreamResponseData = z.object({
  from_variable_selector: z.array(z.string()).nullish(),
  text: z.string(),
})

/**
 * WorkflowStreamDataEvent[Literal['text_chunk'], TextChunkStreamResponse.Data]
 */
export const zWorkflowStreamDataEventLiteralTextChunkData = z.object({
  data: zCoreAppEntitiesTaskEntitiesTextChunkStreamResponseData,
  event: z.literal('text_chunk'),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesTextReplaceStreamResponseData = z.object({
  text: z.string(),
})

/**
 * WorkflowStreamDataEvent[Literal['text_replace'], TextReplaceStreamResponse.Data]
 */
export const zWorkflowStreamDataEventLiteralTextReplaceData = z.object({
  data: zCoreAppEntitiesTaskEntitiesTextReplaceStreamResponseData,
  event: z.literal('text_replace'),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesReasoningChunkStreamResponseData = z.object({
  is_final: z.boolean().optional().default(false),
  message_id: z.string().nullish(),
  node_id: z.string().nullish(),
  reasoning: z.string(),
})

/**
 * WorkflowStreamDataEvent[Literal['reasoning_chunk'], ReasoningChunkStreamResponse.Data]
 */
export const zWorkflowStreamDataEventLiteralReasoningChunkData = z.object({
  data: zCoreAppEntitiesTaskEntitiesReasoningChunkStreamResponseData,
  event: z.literal('reasoning_chunk'),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesAgentLogStreamResponseData = z.object({
  data: z.record(z.string(), z.unknown()),
  error: z.string().nullish(),
  id: z.string(),
  label: z.string(),
  metadata: z.record(z.string(), z.unknown()).optional(),
  node_execution_id: z.string(),
  node_id: z.string(),
  parent_id: z.string().nullish(),
  status: z.string(),
})

/**
 * WorkflowStreamDataEvent[Literal['agent_log'], AgentLogStreamResponse.Data]
 */
export const zWorkflowStreamDataEventLiteralAgentLogData = z.object({
  data: zCoreAppEntitiesTaskEntitiesAgentLogStreamResponseData,
  event: z.literal('agent_log'),
  task_id: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesHumanInputFormFilledResponseData = 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(), z.unknown()).nullish(),
})

/**
 * WorkflowStreamEvent[Literal['human_input_form_filled'], HumanInputFormFilledResponse.Data]
 */
export const zWorkflowStreamEventLiteralHumanInputFormFilledData = z.object({
  data: zCoreAppEntitiesTaskEntitiesHumanInputFormFilledResponseData,
  event: z.literal('human_input_form_filled'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesHumanInputFormTimeoutResponseData = z.object({
  expiration_time: z.int(),
  node_id: z.string(),
  node_title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['human_input_form_timeout'], HumanInputFormTimeoutResponse.Data]
 */
export const zWorkflowStreamEventLiteralHumanInputFormTimeoutData = z.object({
  data: zCoreAppEntitiesTaskEntitiesHumanInputFormTimeoutResponseData,
  event: z.literal('human_input_form_timeout'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * ExecutionActivity
 */
export const zExecutionActivity = z.object({
  id: z.string(),
  kind: z.enum(['node', 'stage']).optional().default('stage'),
  label: z.string(),
  parent_id: z.string().nullish(),
  state: z.enum(['active', 'done', 'failed', 'stopped']),
})

/**
 * ExecutionProgress
 */
export const zExecutionProgress = z.object({
  activities: z.array(zExecutionActivity).optional(),
  status: z.enum(['completed', 'error', 'running', 'stopped']),
})

/**
 * ProgressEventData
 */
export const zProgressEventData = z.object({
  at_version: z.int(),
  execution: zExecutionProgress,
  kind: z.literal('progress').optional().default('progress'),
  operation_id: z.string(),
  revision: z.int(),
  session_id: z.string(),
  stage_id: z.string(),
})

/**
 * DifyBuilderProgressEventResponse
 */
export const zDifyBuilderProgressEventResponse = z.object({
  data: zProgressEventData,
  event: z.literal('progress'),
})

/**
 * AssistantTurnItem
 */
export const zAssistantTurnItem = z.object({
  card_state: z.string().nullish(),
  cards: z.array(z.string()).optional(),
  execution: zExecutionProgress,
  reasoning_text: z.string().nullish(),
  reply_text: z.string().nullish(),
  stage_id: z.string(),
  turn_id: z.string(),
})

/**
 * DifyBuilderAssistantTurnConversationItemResponse
 */
export const zDifyBuilderAssistantTurnConversationItemResponse = z.object({
  at_version: z.int(),
  kind: z.literal('assistant_turn'),
  payload: zAssistantTurnItem,
  seq: z.int(),
})

/**
 * DifyBuilderConversationPageResponse
 */
export const zDifyBuilderConversationPageResponse = z.object({
  data: z.array(
    z.union([
      z
        .object({
          kind: z.literal('user'),
        })
        .and(zDifyBuilderUserConversationItemResponse),
      z
        .object({
          kind: z.literal('decision'),
        })
        .and(zDifyBuilderDecisionConversationItemResponse),
      z
        .object({
          kind: z.literal('notice'),
        })
        .and(zDifyBuilderNoticeConversationItemResponse),
      z
        .object({
          kind: z.literal('run_context'),
        })
        .and(zDifyBuilderRunContextConversationItemResponse),
      z
        .object({
          kind: z.literal('preflight_context'),
        })
        .and(zDifyBuilderPreflightContextConversationItemResponse),
      z
        .object({
          kind: z.literal('assistant_turn'),
        })
        .and(zDifyBuilderAssistantTurnConversationItemResponse),
      z
        .object({
          kind: z.literal('plan'),
        })
        .and(zDifyBuilderPlanConversationItemResponse),
      z
        .object({
          kind: z.literal('form'),
        })
        .and(zDifyBuilderFormConversationItemResponse),
      z
        .object({
          kind: z.literal('challenge'),
        })
        .and(zDifyBuilderChallengeConversationItemResponse),
      z
        .object({
          kind: z.literal('resource_select'),
        })
        .and(zDifyBuilderResourceSelectConversationItemResponse),
      z
        .object({
          kind: z.literal('checkpoint'),
        })
        .and(zDifyBuilderCheckpointConversationItemResponse),
      z
        .object({
          kind: z.literal('change_set'),
        })
        .and(zDifyBuilderChangeSetConversationItemResponse),
      z
        .object({
          kind: z.literal('test_result'),
        })
        .and(zDifyBuilderTestResultConversationItemResponse),
      z
        .object({
          kind: z.literal('error'),
        })
        .and(zDifyBuilderErrorConversationItemResponse),
      z
        .object({
          kind: z.literal('summary'),
        })
        .and(zDifyBuilderSummaryConversationItemResponse),
      z
        .object({
          kind: z.literal('publish'),
        })
        .and(zDifyBuilderPublishConversationItemResponse),
      z
        .object({
          kind: z.literal('build_learning'),
        })
        .and(zDifyBuilderBuildLearningConversationItemResponse),
    ]),
  ),
  first_seq: z.int().nullable(),
  has_more: z.boolean(),
  last_seq: z.int().nullable(),
})

/**
 * DifyBuilderActiveInteractionResponse
 */
export const zDifyBuilderActiveInteractionResponse = z.object({
  action_id: z.string(),
  card: z.discriminatedUnion('kind', [
    zDifyBuilderUserConversationItemResponse.extend({ kind: z.literal('user') }),
    zDifyBuilderDecisionConversationItemResponse.extend({ kind: z.literal('decision') }),
    zDifyBuilderNoticeConversationItemResponse.extend({ kind: z.literal('notice') }),
    zDifyBuilderRunContextConversationItemResponse.extend({ kind: z.literal('run_context') }),
    zDifyBuilderPreflightContextConversationItemResponse.extend({
      kind: z.literal('preflight_context'),
    }),
    zDifyBuilderAssistantTurnConversationItemResponse.extend({ kind: z.literal('assistant_turn') }),
    zDifyBuilderPlanConversationItemResponse.extend({ kind: z.literal('plan') }),
    zDifyBuilderFormConversationItemResponse.extend({ kind: z.literal('form') }),
    zDifyBuilderChallengeConversationItemResponse.extend({ kind: z.literal('challenge') }),
    zDifyBuilderResourceSelectConversationItemResponse.extend({
      kind: z.literal('resource_select'),
    }),
    zDifyBuilderCheckpointConversationItemResponse.extend({ kind: z.literal('checkpoint') }),
    zDifyBuilderChangeSetConversationItemResponse.extend({ kind: z.literal('change_set') }),
    zDifyBuilderTestResultConversationItemResponse.extend({ kind: z.literal('test_result') }),
    zDifyBuilderErrorConversationItemResponse.extend({ kind: z.literal('error') }),
    zDifyBuilderSummaryConversationItemResponse.extend({ kind: z.literal('summary') }),
    zDifyBuilderPublishConversationItemResponse.extend({ kind: z.literal('publish') }),
    zDifyBuilderBuildLearningConversationItemResponse.extend({ kind: z.literal('build_learning') }),
  ]),
  valid_at_version: z.int(),
})

/**
 * DifyBuilderSessionViewResponse
 */
export const zDifyBuilderSessionViewResponse = z.object({
  actions: z.array(zAction).optional(),
  active_interaction: zDifyBuilderActiveInteractionResponse.nullish(),
  app_id: z.string(),
  app_revision: zAppRevision.nullish(),
  canvas_read_only: z.boolean(),
  checkpoint: zCheckpointRef.nullish(),
  conversation_last_seq: z.int(),
  decision: zDecision.nullish(),
  entry_mode: zEntryMode.optional().default('fix'),
  interrupted: z.boolean(),
  model: zSessionModel.nullish(),
  phase: zPhase.optional().default('understand'),
  recovery: zRecoveryRef.nullish(),
  run_status: zRunStatus,
  session_id: z.string(),
  state: z.string(),
  version: z.int(),
})

/**
 * DifyBuilderCommandStartedEventData
 */
export const zDifyBuilderCommandStartedEventData = z.object({
  actions: z.array(zAction).optional(),
  active_interaction: zDifyBuilderActiveInteractionResponse.nullish(),
  app_id: z.string(),
  app_revision: zAppRevision.nullish(),
  canvas_read_only: z.boolean(),
  checkpoint: zCheckpointRef.nullish(),
  conversation_last_seq: z.int(),
  decision: zDecision.nullish(),
  entry_mode: zEntryMode.optional().default('fix'),
  interrupted: z.boolean(),
  kind: z.literal('command_started').optional().default('command_started'),
  model: zSessionModel.nullish(),
  phase: zPhase.optional().default('understand'),
  recovery: zRecoveryRef.nullish(),
  run_status: zRunStatus,
  session_id: z.string(),
  state: z.string(),
  version: z.int(),
})

/**
 * DifyBuilderCommandStartedEventResponse
 */
export const zDifyBuilderCommandStartedEventResponse = z.object({
  data: zDifyBuilderCommandStartedEventData,
  event: z.literal('command_started'),
})

/**
 * DifyBuilderCommitEventData
 */
export const zDifyBuilderCommitEventData = z.object({
  at_version: z.int(),
  items: z.array(
    z.union([
      z
        .object({
          kind: z.literal('user'),
        })
        .and(zDifyBuilderUserConversationItemResponse),
      z
        .object({
          kind: z.literal('decision'),
        })
        .and(zDifyBuilderDecisionConversationItemResponse),
      z
        .object({
          kind: z.literal('notice'),
        })
        .and(zDifyBuilderNoticeConversationItemResponse),
      z
        .object({
          kind: z.literal('run_context'),
        })
        .and(zDifyBuilderRunContextConversationItemResponse),
      z
        .object({
          kind: z.literal('preflight_context'),
        })
        .and(zDifyBuilderPreflightContextConversationItemResponse),
      z
        .object({
          kind: z.literal('assistant_turn'),
        })
        .and(zDifyBuilderAssistantTurnConversationItemResponse),
      z
        .object({
          kind: z.literal('plan'),
        })
        .and(zDifyBuilderPlanConversationItemResponse),
      z
        .object({
          kind: z.literal('form'),
        })
        .and(zDifyBuilderFormConversationItemResponse),
      z
        .object({
          kind: z.literal('challenge'),
        })
        .and(zDifyBuilderChallengeConversationItemResponse),
      z
        .object({
          kind: z.literal('resource_select'),
        })
        .and(zDifyBuilderResourceSelectConversationItemResponse),
      z
        .object({
          kind: z.literal('checkpoint'),
        })
        .and(zDifyBuilderCheckpointConversationItemResponse),
      z
        .object({
          kind: z.literal('change_set'),
        })
        .and(zDifyBuilderChangeSetConversationItemResponse),
      z
        .object({
          kind: z.literal('test_result'),
        })
        .and(zDifyBuilderTestResultConversationItemResponse),
      z
        .object({
          kind: z.literal('error'),
        })
        .and(zDifyBuilderErrorConversationItemResponse),
      z
        .object({
          kind: z.literal('summary'),
        })
        .and(zDifyBuilderSummaryConversationItemResponse),
      z
        .object({
          kind: z.literal('publish'),
        })
        .and(zDifyBuilderPublishConversationItemResponse),
      z
        .object({
          kind: z.literal('build_learning'),
        })
        .and(zDifyBuilderBuildLearningConversationItemResponse),
    ]),
  ),
  kind: z.literal('commit').optional().default('commit'),
  operation_id: z.string(),
  session_id: z.string(),
  settled: z.boolean(),
  stage_id: z.string(),
  state: z.string(),
  version: z.int(),
})

/**
 * DifyBuilderCommitEventResponse
 */
export const zDifyBuilderCommitEventResponse = z.object({
  data: zDifyBuilderCommitEventData,
  event: z.literal('commit'),
})

/**
 * DifyBuilderStateEventData
 */
export const zDifyBuilderStateEventData = z.object({
  actions: z.array(zAction).optional(),
  active_interaction: zDifyBuilderActiveInteractionResponse.nullish(),
  app_id: z.string(),
  app_revision: zAppRevision.nullish(),
  canvas_read_only: z.boolean(),
  checkpoint: zCheckpointRef.nullish(),
  conversation_last_seq: z.int(),
  decision: zDecision.nullish(),
  entry_mode: zEntryMode.optional().default('fix'),
  interrupted: z.boolean(),
  kind: z.literal('state').optional().default('state'),
  model: zSessionModel.nullish(),
  phase: zPhase.optional().default('understand'),
  recovery: zRecoveryRef.nullish(),
  run_status: zRunStatus,
  session_id: z.string(),
  state: z.string(),
  version: z.int(),
})

/**
 * DifyBuilderStateEventResponse
 */
export const zDifyBuilderStateEventResponse = z.object({
  data: zDifyBuilderStateEventData,
  event: z.literal('state'),
})

/**
 * WorkflowStartReason
 *
 * Reason for workflow start events across graph/queue/SSE layers.
 */
export const zWorkflowStartReason = z.enum(['initial', 'resumption'])

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesWorkflowStartStreamResponseData = z.object({
  created_at: z.int(),
  id: z.string(),
  inputs: z.record(z.string(), z.unknown()),
  reason: zWorkflowStartReason.optional().default('initial'),
  workflow_id: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['workflow_started'], WorkflowStartStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralWorkflowStartedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesWorkflowStartStreamResponseData,
  event: z.literal('workflow_started'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * WorkflowExecutionStatus
 */
export const zWorkflowExecutionStatus = z.enum([
  'failed',
  'partial-succeeded',
  'paused',
  'running',
  'scheduled',
  'stopped',
  'succeeded',
])

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesWorkflowFinishStreamResponseData = z.object({
  created_at: z.int(),
  created_by: z.record(z.string(), z.unknown()).optional(),
  elapsed_time: z.number(),
  error: z.string().nullish(),
  exceptions_count: z.int().optional().default(0),
  files: z.array(z.record(z.string(), z.unknown())).nullish().default([]),
  finished_at: z.int().nullable(),
  id: z.string(),
  outputs: z.record(z.string(), z.unknown()).nullish(),
  status: zWorkflowExecutionStatus,
  total_steps: z.int(),
  total_tokens: z.int(),
  workflow_id: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['workflow_finished'], WorkflowFinishStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralWorkflowFinishedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesWorkflowFinishStreamResponseData,
  event: z.literal('workflow_finished'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesWorkflowPauseStreamResponseData = z.object({
  created_at: z.int(),
  elapsed_time: z.number(),
  outputs: z.record(z.string(), z.unknown()).optional(),
  paused_nodes: z.array(z.string()).optional(),
  reasons: z.array(z.record(z.string(), z.unknown())).optional(),
  status: zWorkflowExecutionStatus,
  total_steps: z.int(),
  total_tokens: z.int(),
  workflow_run_id: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['workflow_paused'], WorkflowPauseStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralWorkflowPausedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesWorkflowPauseStreamResponseData,
  event: z.literal('workflow_paused'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * AgentStrategyInfo
 */
export const zAgentStrategyInfo = z.object({
  icon: z.string().nullish(),
  name: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesNodeStartStreamResponseData = z.object({
  agent_strategy: zAgentStrategyInfo.nullish(),
  created_at: z.int(),
  extras: z.record(z.string(), z.unknown()).optional(),
  id: z.string(),
  index: z.int(),
  inputs: z.record(z.string(), z.unknown()).nullish(),
  inputs_truncated: z.boolean().optional().default(false),
  iteration_id: z.string().nullish(),
  loop_id: z.string().nullish(),
  node_id: z.string(),
  node_type: z.string(),
  predecessor_node_id: z.string().nullish(),
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['node_started'], NodeStartStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralNodeStartedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesNodeStartStreamResponseData,
  event: z.literal('node_started'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * WorkflowNodeExecutionMetadataKey
 *
 * Node Run Metadata Key.
 *
 * Values in this enum are persisted as execution metadata and must stay in sync
 * with every node that writes `NodeRunResult.metadata`.
 */
export const zWorkflowNodeExecutionMetadataKey = z.enum([
  'agent_log',
  'completed_reason',
  'currency',
  'datasource_info',
  'error_strategy',
  'iteration_duration_map',
  'iteration_id',
  'iteration_index',
  'loop_duration_map',
  'loop_id',
  'loop_index',
  'loop_variable_map',
  'parallel_id',
  'parallel_mode_run_id',
  'parallel_start_node_id',
  'parent_parallel_id',
  'parent_parallel_start_node_id',
  'tool_info',
  'total_price',
  'total_tokens',
  'trigger_info',
])

/**
 * WorkflowNodeExecutionStatus
 */
export const zWorkflowNodeExecutionStatus = z.enum([
  'exception',
  'failed',
  'paused',
  'pending',
  'retry',
  'running',
  'stopped',
  'succeeded',
])

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesNodeFinishStreamResponseData = z.object({
  created_at: z.int(),
  elapsed_time: z.number(),
  error: z.string().nullish(),
  execution_metadata: z.record(z.string(), z.unknown()).nullish(),
  files: z.array(z.record(z.string(), z.unknown())).nullish().default([]),
  finished_at: z.int(),
  id: z.string(),
  index: z.int(),
  inputs: z.record(z.string(), z.unknown()).nullish(),
  inputs_truncated: z.boolean().optional().default(false),
  iteration_id: z.string().nullish(),
  loop_id: z.string().nullish(),
  node_id: z.string(),
  node_type: z.string(),
  outputs: z.record(z.string(), z.unknown()).nullish(),
  outputs_truncated: z.boolean().optional().default(true),
  predecessor_node_id: z.string().nullish(),
  process_data: z.record(z.string(), z.unknown()).nullish(),
  process_data_truncated: z.boolean().optional().default(false),
  status: zWorkflowNodeExecutionStatus,
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['node_finished'], NodeFinishStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralNodeFinishedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesNodeFinishStreamResponseData,
  event: z.literal('node_finished'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesNodeRetryStreamResponseData = z.object({
  created_at: z.int(),
  elapsed_time: z.number(),
  error: z.string().nullish(),
  execution_metadata: z.record(z.string(), z.unknown()).nullish(),
  files: z.array(z.record(z.string(), z.unknown())).nullish().default([]),
  finished_at: z.int(),
  id: z.string(),
  index: z.int(),
  inputs: z.record(z.string(), z.unknown()).nullish(),
  inputs_truncated: z.boolean().optional().default(false),
  iteration_id: z.string().nullish(),
  loop_id: z.string().nullish(),
  node_id: z.string(),
  node_type: z.string(),
  outputs: z.record(z.string(), z.unknown()).nullish(),
  outputs_truncated: z.boolean().optional().default(false),
  predecessor_node_id: z.string().nullish(),
  process_data: z.record(z.string(), z.unknown()).nullish(),
  process_data_truncated: z.boolean().optional().default(false),
  retry_index: z.int().optional().default(0),
  status: zWorkflowNodeExecutionStatus,
  title: z.string(),
})

/**
 * WorkflowStreamEvent[Literal['node_retry'], NodeRetryStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralNodeRetryData = z.object({
  data: zCoreAppEntitiesTaskEntitiesNodeRetryStreamResponseData,
  event: z.literal('node_retry'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesIterationNodeCompletedStreamResponseData = z.object({
  created_at: z.int(),
  elapsed_time: z.number(),
  error: z.string().nullish(),
  execution_metadata: z.record(z.string(), z.unknown()).optional(),
  extras: z.record(z.string(), z.unknown()).nullish(),
  finished_at: z.int(),
  id: z.string(),
  inputs: z.record(z.string(), z.unknown()).nullish(),
  inputs_truncated: z.boolean().optional().default(false),
  node_id: z.string(),
  node_type: z.string(),
  outputs: z.record(z.string(), z.unknown()).nullish(),
  outputs_truncated: z.boolean().optional().default(false),
  status: zWorkflowNodeExecutionStatus,
  steps: z.int(),
  title: z.string(),
  total_tokens: z.int(),
})

/**
 * WorkflowStreamEvent[Literal['iteration_completed'], IterationNodeCompletedStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralIterationCompletedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesIterationNodeCompletedStreamResponseData,
  event: z.literal('iteration_completed'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesLoopNodeCompletedStreamResponseData = z.object({
  created_at: z.int(),
  elapsed_time: z.number(),
  error: z.string().nullish(),
  execution_metadata: z.record(z.string(), z.unknown()).optional(),
  extras: z.record(z.string(), z.unknown()).nullish(),
  finished_at: z.int(),
  id: z.string(),
  inputs: z.record(z.string(), z.unknown()).nullish(),
  inputs_truncated: z.boolean().optional().default(false),
  node_id: z.string(),
  node_type: z.string(),
  outputs: z.record(z.string(), z.unknown()).nullish(),
  outputs_truncated: z.boolean().optional().default(false),
  status: zWorkflowNodeExecutionStatus,
  steps: z.int(),
  title: z.string(),
  total_tokens: z.int(),
})

/**
 * WorkflowStreamEvent[Literal['loop_completed'], LoopNodeCompletedStreamResponse.Data]
 */
export const zWorkflowStreamEventLiteralLoopCompletedData = z.object({
  data: zCoreAppEntitiesTaskEntitiesLoopNodeCompletedStreamResponseData,
  event: z.literal('loop_completed'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

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

/**
 * UserActionConfig
 *
 * User action configuration.
 */
export const zUserActionConfig = z.object({
  button_style: zButtonStyle.optional().default('default'),
  id: z
    .string()
    .max(20)
    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
  title: z.string().max(100),
})

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

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

/**
 * 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'),
})

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

/**
 * 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'),
})

/**
 * 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'),
})

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') }),
])

/**
 * Data
 *
 * Data entity
 */
export const zCoreAppEntitiesTaskEntitiesHumanInputRequiredResponseData = z.object({
  actions: z.array(zUserActionConfig).optional(),
  approval_channels: z.array(z.string()).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(),
})

/**
 * WorkflowStreamEvent[Literal['human_input_required'], HumanInputRequiredResponse.Data]
 */
export const zWorkflowStreamEventLiteralHumanInputRequiredData = z.object({
  data: zCoreAppEntitiesTaskEntitiesHumanInputRequiredResponseData,
  event: z.literal('human_input_required'),
  task_id: z.string(),
  workflow_run_id: z.string(),
})

/**
 * DifyBuilderWorkflowEventData
 */
export const zDifyBuilderWorkflowEventData = z.object({
  at_version: z.int(),
  kind: z.literal('workflow').optional().default('workflow'),
  operation_id: z.string(),
  payload: z.union([
    z
      .object({
        event: z.literal('workflow_started'),
      })
      .and(zWorkflowStreamEventLiteralWorkflowStartedData),
    z
      .object({
        event: z.literal('workflow_finished'),
      })
      .and(zWorkflowStreamEventLiteralWorkflowFinishedData),
    z
      .object({
        event: z.literal('workflow_paused'),
      })
      .and(zWorkflowStreamEventLiteralWorkflowPausedData),
    z
      .object({
        event: z.literal('node_started'),
      })
      .and(zWorkflowStreamEventLiteralNodeStartedData),
    z
      .object({
        event: z.literal('node_finished'),
      })
      .and(zWorkflowStreamEventLiteralNodeFinishedData),
    z
      .object({
        event: z.literal('node_retry'),
      })
      .and(zWorkflowStreamEventLiteralNodeRetryData),
    z
      .object({
        event: z.literal('iteration_started'),
      })
      .and(zWorkflowStreamEventLiteralIterationStartedData),
    z
      .object({
        event: z.literal('iteration_next'),
      })
      .and(zWorkflowStreamEventLiteralIterationNextData),
    z
      .object({
        event: z.literal('iteration_completed'),
      })
      .and(zWorkflowStreamEventLiteralIterationCompletedData),
    z
      .object({
        event: z.literal('loop_started'),
      })
      .and(zWorkflowStreamEventLiteralLoopStartedData),
    z
      .object({
        event: z.literal('loop_next'),
      })
      .and(zWorkflowStreamEventLiteralLoopNextData),
    z
      .object({
        event: z.literal('loop_completed'),
      })
      .and(zWorkflowStreamEventLiteralLoopCompletedData),
    z
      .object({
        event: z.literal('text_chunk'),
      })
      .and(zWorkflowStreamDataEventLiteralTextChunkData),
    z
      .object({
        event: z.literal('text_replace'),
      })
      .and(zWorkflowStreamDataEventLiteralTextReplaceData),
    z
      .object({
        event: z.literal('reasoning_chunk'),
      })
      .and(zWorkflowStreamDataEventLiteralReasoningChunkData),
    z
      .object({
        event: z.literal('agent_log'),
      })
      .and(zWorkflowStreamDataEventLiteralAgentLogData),
    z
      .object({
        event: z.literal('human_input_required'),
      })
      .and(zWorkflowStreamEventLiteralHumanInputRequiredData),
    z
      .object({
        event: z.literal('human_input_form_filled'),
      })
      .and(zWorkflowStreamEventLiteralHumanInputFormFilledData),
    z
      .object({
        event: z.literal('human_input_form_timeout'),
      })
      .and(zWorkflowStreamEventLiteralHumanInputFormTimeoutData),
    z
      .object({
        event: z.union([z.literal('tts_message'), z.literal('tts_message_end')]),
      })
      .and(zWorkflowStreamAudio),
    z
      .object({
        event: z.literal('message'),
      })
      .and(zWorkflowStreamMessage),
    z
      .object({
        event: z.literal('message_end'),
      })
      .and(zWorkflowStreamMessageEnd),
    z
      .object({
        event: z.literal('message_file'),
      })
      .and(zWorkflowStreamMessageFile),
    z
      .object({
        event: z.literal('message_replace'),
      })
      .and(zWorkflowStreamMessageReplace),
    z
      .object({
        event: z.literal('error'),
      })
      .and(zWorkflowStreamError),
  ]),
  revision: z.int(),
  session_id: z.string(),
  stage_id: z.string(),
})

/**
 * DifyBuilderWorkflowEventResponse
 */
export const zDifyBuilderWorkflowEventResponse = z.object({
  data: zDifyBuilderWorkflowEventData,
  event: z.literal('workflow'),
})

/**
 * DifyBuilderStreamEventResponse
 *
 * One JSON object carried by an SSE ``data:`` frame.
 */
export const zDifyBuilderStreamEventResponse = z.discriminatedUnion('event', [
  zDifyBuilderCommandStartedEventResponse.extend({ event: z.literal('command_started') }),
  zDifyBuilderWorkflowEventResponse.extend({ event: z.literal('workflow') }),
  zDifyBuilderCanvasEventResponse.extend({ event: z.literal('canvas') }),
  zDifyBuilderAgentMessageEventResponse.extend({ event: z.literal('agent_message') }),
  zDifyBuilderReasoningEventResponse.extend({ event: z.literal('reasoning') }),
  zDifyBuilderProgressEventResponse.extend({ event: z.literal('progress') }),
  zDifyBuilderCommitEventResponse.extend({ event: z.literal('commit') }),
  zDifyBuilderStateEventResponse.extend({ event: z.literal('state') }),
  zDifyBuilderErrorEventResponse.extend({ event: z.literal('error') }),
])

/**
 * Success
 */
export const zPostDifyBuilderAgentPingResponse = z.record(z.string(), z.unknown())

export const zPostDifyBuilderSessionsBody = zDifyBuilderCreateSessionPayload

/**
 * Dify Builder event stream
 */
export const zPostDifyBuilderSessionsResponse = zDifyBuilderStreamEventResponse

export const zGetDifyBuilderSessionsBySessionIdPath = z.object({
  session_id: z.string(),
})

/**
 * Dify Builder session state
 */
export const zGetDifyBuilderSessionsBySessionIdResponse = zDifyBuilderSessionViewResponse

export const zPostDifyBuilderSessionsBySessionIdActionsBody = zDifyBuilderSubmitActionPayload

export const zPostDifyBuilderSessionsBySessionIdActionsPath = z.object({
  session_id: z.string(),
})

/**
 * Dify Builder event stream
 */
export const zPostDifyBuilderSessionsBySessionIdActionsResponse = zDifyBuilderStreamEventResponse

export const zGetDifyBuilderSessionsBySessionIdConversationPath = z.object({
  session_id: z.string(),
})

export const zGetDifyBuilderSessionsBySessionIdConversationQuery = z.object({
  after_seq: z.int().gte(-1).optional(),
  before_seq: z.int().gte(0).optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
})

/**
 * Dify Builder conversation page
 */
export const zGetDifyBuilderSessionsBySessionIdConversationResponse =
  zDifyBuilderConversationPageResponse

export const zPostDifyBuilderSessionsBySessionIdMessagesBody = zDifyBuilderSubmitMessagePayload

export const zPostDifyBuilderSessionsBySessionIdMessagesPath = z.object({
  session_id: z.string(),
})

/**
 * Dify Builder event stream
 */
export const zPostDifyBuilderSessionsBySessionIdMessagesResponse = zDifyBuilderStreamEventResponse

export const zGetDifyBuilderSessionsBySessionIdStreamPath = z.object({
  session_id: z.string(),
})

/**
 * Dify Builder reconnect event stream
 */
export const zGetDifyBuilderSessionsBySessionIdStreamResponse = zDifyBuilderStreamEventResponse