Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

225 KB
Raw Blame
// This file is auto-generated by @hey-api/openapi-ts

import * as z from 'zod'

/**
 * ErrorResponse
 *
 * Documented non-2xx body emitted by ``register_external_error_handlers``.
 *
 * ``params`` and ``details`` appear only on the errors that set them. The schema
 * stays open because ``HTTPException.data`` may carry extra keys.
 */
export const zErrorResponse = z.object({
  code: z.string(),
  details: z.record(z.string(), z.unknown()).optional(),
  message: z.string(),
  params: z.string().optional(),
  status: z.int(),
})

/**
 * AppImportPayload
 */
export const zAppImportPayload = z.object({
  app_id: z.string().nullish(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  mode: z.string(),
  name: z.string().nullish(),
  package_url: z.string().nullish(),
  template_id: z.uuid().nullish(),
  version_id: z.uuid().nullish(),
  yaml_content: z.string().nullish(),
  yaml_url: z.string().nullish(),
})

/**
 * InvalidRosterAgentPackageError
 *
 * The Roster Agent package is invalid.
 */
export const zInvalidRosterAgentPackageError = zErrorResponse.and(
  z.object({
    code: z.literal('invalid_roster_agent_package'),
    status: z.literal(400),
  }),
)

/**
 * RecommendedAppNotFoundError
 *
 * Recommended app not found.
 */
export const zRecommendedAppNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('recommended_app_not_found'),
    status: z.literal(404),
  }),
)

/**
 * AgentNameConflictError
 *
 * Agent name already exists.
 */
export const zAgentNameConflictError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_name_conflict_error'),
    status: z.literal(409),
  }),
)

/**
 * RosterAgentPackageTooLargeError
 *
 * The Roster Agent package exceeds the size limit.
 */
export const zRosterAgentPackageTooLargeError = zErrorResponse.and(
  z.object({
    code: z.literal('roster_agent_package_too_large'),
    status: z.literal(413),
  }),
)

/**
 * RosterAgentPackageImportFailedError
 *
 * The Roster Agent package could not be imported.
 */
export const zRosterAgentPackageImportFailedError = zErrorResponse.and(
  z.object({
    code: z.literal('roster_agent_package_import_failed'),
    status: z.literal(500),
  }),
)

/**
 * RosterAgentPackageResourceUnavailableError
 *
 * The Roster Agent package resources could not be stored.
 */
export const zRosterAgentPackageResourceUnavailableError = zErrorResponse.and(
  z.object({
    code: z.literal('roster_agent_package_resource_unavailable'),
    status: z.literal(503),
  }),
)

/**
 * AppNotFoundError
 *
 * App not found.
 */
export const zAppNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('app_not_found'),
    status: z.literal(404),
  }),
)

/**
 * WorkflowOnlineUsersPayload
 */
export const zWorkflowOnlineUsersPayload = z.object({
  app_ids: z.array(z.string()).optional(),
})

/**
 * WorkflowRunCountResponse
 */
export const zWorkflowRunCountResponse = z.object({
  failed: z.int(),
  partial_succeeded: z.int(),
  running: z.int(),
  stopped: z.int(),
  succeeded: z.int(),
  total: z.int(),
})

/**
 * HumanInputFormPreviewPayload
 */
export const zHumanInputFormPreviewPayload = z.object({
  inputs: z.record(z.string(), z.unknown()).optional(),
})

/**
 * HumanInputFormPreviewSubmitPayload
 */
export const zHumanInputFormPreviewSubmitPayload = z.object({
  action: z.string(),
  form_inputs: z.record(z.string(), z.unknown()),
  inputs: z.record(z.string(), z.unknown()),
})

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

/**
 * MessageTemplateTestResponse
 *
 * Response body returned after one message-template test send.
 */
export const zMessageTemplateTestResponse = z.record(z.string(), z.unknown())

/**
 * IterationNodeRunPayload
 */
export const zIterationNodeRunPayload = z.object({
  inputs: z.record(z.string(), z.unknown()).nullish(),
})

/**
 * LoopNodeRunPayload
 */
export const zLoopNodeRunPayload = z.object({
  inputs: z.record(z.string(), z.unknown()).nullish(),
})

/**
 * AdvancedChatWorkflowRunPayload
 */
export const zAdvancedChatWorkflowRunPayload = z.object({
  conversation_id: z.string().nullish(),
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  inputs: z.record(z.string(), z.unknown()).nullish(),
  parent_message_id: z.string().nullish(),
  query: z.string().optional().default(''),
})

/**
 * RateLimitError
 *
 * Rate Limit Error
 */
export const zRateLimitError = zErrorResponse.and(
  z.object({
    code: z.literal('rate_limit_error'),
    status: z.literal(429),
  }),
)

/**
 * AgentNotBoundError
 *
 * no agent is bound for this app/node
 */
export const zAgentNotBoundError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_not_bound'),
    status: z.literal(400),
  }),
)

/**
 * AgentNotFoundError
 *
 * Agent not found.
 */
export const zAgentNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_not_found_error'),
    status: z.literal(404),
  }),
)

/**
 * AgentConfigFileUploadPayload
 */
export const zAgentConfigFileUploadPayload = z.object({
  upload_file_id: z.string(),
})

/**
 * AgentConfigFilesUploadPayload
 */
export const zAgentConfigFilesUploadPayload = z.object({
  upload_file_ids: z.array(z.uuid()).min(1),
})

/**
 * AgentConfigDeleteResponse
 */
export const zAgentConfigDeleteResponse = z.object({
  removed_names: z.array(z.string()).optional(),
  result: z.literal('success'),
})

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

/**
 * AgentConfigFilePreviewResponse
 */
export const zAgentConfigFilePreviewResponse = z.object({
  binary: z.boolean(),
  name: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * AgentConfigSkillFilePreviewResponse
 */
export const zAgentConfigSkillFilePreviewResponse = z.object({
  binary: z.boolean(),
  path: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

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

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

/**
 * AnnotationJobStatusDetailResponse
 */
export const zAnnotationJobStatusDetailResponse = z.object({
  error_msg: z.string().optional().default(''),
  job_id: z.uuid(),
  job_status: z.string(),
})

/**
 * AnnotationSettingUpdatePayload
 */
export const zAnnotationSettingUpdatePayload = z.object({
  score_threshold: z.number(),
})

/**
 * BadRequestError
 *
 * annotation_ids are required if the parameter is provided.
 */
export const zBadRequestError = zErrorResponse.and(
  z.object({
    code: z.literal('bad_request'),
    status: z.literal(400),
  }),
)

/**
 * CreateAnnotationPayload
 */
export const zCreateAnnotationPayload = z.object({
  annotation_reply: z.record(z.string(), z.unknown()).nullish(),
  answer: z.string().nullish(),
  content: z.string().nullish(),
  message_id: z.string().nullish(),
  question: z.string().nullish(),
})

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

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

/**
 * AnnotationBatchImportResponse
 */
export const zAnnotationBatchImportResponse = z.object({
  error_msg: z.string().nullish(),
  job_id: z.string().nullish(),
  job_status: z.string().nullish(),
  record_count: z.int().nullish(),
})

/**
 * NoFileUploadedError
 *
 * Please upload your file.
 */
export const zNoFileUploadedError = zErrorResponse.and(
  z.object({
    code: z.literal('no_file_uploaded'),
    status: z.literal(400),
  }),
)

/**
 * TooManyFilesError
 *
 * Only one file is allowed.
 */
export const zTooManyFilesError = zErrorResponse.and(
  z.object({
    code: z.literal('too_many_files'),
    status: z.literal(400),
  }),
)

/**
 * AnnotationCountResponse
 */
export const zAnnotationCountResponse = z.object({
  count: z.int(),
})

/**
 * AnnotationExportList
 */
export const zAnnotationExportList = z.object({
  data: z.array(zAnnotation),
})

/**
 * UpdateAnnotationPayload
 */
export const zUpdateAnnotationPayload = z.object({
  annotation_reply: z.record(z.string(), z.unknown()).nullish(),
  answer: z.string().nullish(),
  content: z.string().nullish(),
  question: z.string().nullish(),
})

/**
 * AppApiStatusPayload
 */
export const zAppApiStatusPayload = z.object({
  enable_api: z.boolean(),
})

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

/**
 * AppUnavailableError
 *
 * App unavailable, please check your app configurations.
 */
export const zAppUnavailableError = zErrorResponse.and(
  z.object({
    code: z.literal('app_unavailable'),
    status: z.literal(400),
  }),
)

/**
 * CompletionRequestError
 *
 * Completion request failed.
 */
export const zCompletionRequestError = zErrorResponse.and(
  z.object({
    code: z.literal('completion_request_error'),
    status: z.literal(400),
  }),
)

/**
 * ModelCurrentlyNotSupportError
 *
 * Dify Hosted OpenAI trial currently not support the GPT-4 model.
 */
export const zModelCurrentlyNotSupportError = zErrorResponse.and(
  z.object({
    code: z.literal('model_currently_not_support'),
    status: z.literal(400),
  }),
)

/**
 * NoAudioUploadedError
 *
 * Please upload your audio.
 */
export const zNoAudioUploadedError = zErrorResponse.and(
  z.object({
    code: z.literal('no_audio_uploaded'),
    status: z.literal(400),
  }),
)

/**
 * ProviderNotInitializeError
 *
 * No valid model provider credentials found. Please go to Settings -> Model Provider to complete your provider credentials.
 */
export const zProviderNotInitializeError = zErrorResponse.and(
  z.object({
    code: z.literal('provider_not_initialize'),
    status: z.literal(400),
  }),
)

/**
 * ProviderNotSupportSpeechToTextError
 *
 * Provider not support speech to text.
 */
export const zProviderNotSupportSpeechToTextError = zErrorResponse.and(
  z.object({
    code: z.literal('provider_not_support_speech_to_text'),
    status: z.literal(400),
  }),
)

/**
 * ProviderQuotaExceededError
 *
 * Your quota for Dify Hosted Model Provider has been exhausted. Please go to Settings -> Model Provider to complete your own provider credentials.
 */
export const zProviderQuotaExceededError = zErrorResponse.and(
  z.object({
    code: z.literal('provider_quota_exceeded'),
    status: z.literal(400),
  }),
)

/**
 * SpeechToTextDisabledError
 *
 * Speech to text is disabled.
 */
export const zSpeechToTextDisabledError = zErrorResponse.and(
  z.object({
    code: z.literal('speech_to_text_disabled'),
    status: z.literal(400),
  }),
)

/**
 * AgentVersionNotFoundError
 *
 * Agent config version not found.
 */
export const zAgentVersionNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_version_not_found_error'),
    status: z.literal(404),
  }),
)

/**
 * AudioTooLargeError
 *
 * Audio size exceeded. {message}
 */
export const zAudioTooLargeError = zErrorResponse.and(
  z.object({
    code: z.literal('audio_too_large'),
    status: z.literal(413),
  }),
)

/**
 * UnsupportedAudioTypeError
 *
 * Audio type not allowed.
 */
export const zUnsupportedAudioTypeError = zErrorResponse.and(
  z.object({
    code: z.literal('unsupported_audio_type'),
    status: z.literal(415),
  }),
)

/**
 * ConversationNotFoundError
 *
 * The conversation was not found for this user and app.
 */
export const zConversationNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('conversation_not_found'),
    status: z.literal(404),
  }),
)

/**
 * SuggestedQuestionsResponse
 */
export const zSuggestedQuestionsResponse = z.object({
  data: z.array(z.string()),
})

/**
 * AppSuggestedQuestionsAfterAnswerDisabledError
 *
 * Function Suggested questions after answer disabled.
 */
export const zAppSuggestedQuestionsAfterAnswerDisabledError = zErrorResponse.and(
  z.object({
    code: z.literal('app_suggested_questions_after_answer_disabled'),
    status: z.literal(403),
  }),
)

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

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

/**
 * ConvertToWorkflowPayload
 */
export const zConvertToWorkflowPayload = z.object({
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  name: z.string().nullish(),
})

/**
 * NewAppResponse
 */
export const zNewAppResponse = z.object({
  new_app_id: z.string(),
  permission_keys: z.array(z.string()).optional(),
})

/**
 * AppExportResponse
 */
export const zAppExportResponse = z.object({
  data: z.string(),
})

/**
 * RosterAgentPackageExportFailedError
 *
 * The Roster Agent package could not be exported.
 */
export const zRosterAgentPackageExportFailedError = zErrorResponse.and(
  z.object({
    code: z.literal('roster_agent_package_export_failed'),
    status: z.literal(500),
  }),
)

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

/**
 * MessageFeedbackRatingRequiredError
 *
 * A rating is required when there is no existing feedback to remove.
 */
export const zMessageFeedbackRatingRequiredError = zErrorResponse.and(
  z.object({
    code: z.literal('message_feedback_rating_required'),
    status: z.literal(400),
  }),
)

/**
 * AppNamePayload
 */
export const zAppNamePayload = z.object({
  name: z.string().min(1),
})

/**
 * NetworkAccessUnsupportedAppModeError
 *
 * Network access control is not supported for this app mode.
 */
export const zNetworkAccessUnsupportedAppModeError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_unsupported_app_mode'),
    status: z.literal(400),
  }),
)

/**
 * NetworkAccessForbiddenError
 *
 * Network access groups are not available for this workspace.
 */
export const zNetworkAccessForbiddenError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_forbidden'),
    status: z.literal(403),
  }),
)

/**
 * NetworkAccessNotEntitledError
 *
 * Network access groups are not available for this workspace.
 */
export const zNetworkAccessNotEntitledError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_not_entitled'),
    status: z.literal(403),
  }),
)

/**
 * NetworkAccessRoleDeniedError
 *
 * Your workspace role does not allow this network access operation.
 */
export const zNetworkAccessRoleDeniedError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_role_denied'),
    status: z.literal(403),
  }),
)

/**
 * BillingOperationFailedError
 *
 * We couldn't complete this request. Please try again. If the problem persists, contact support.
 */
export const zBillingOperationFailedError = zErrorResponse.and(
  z.object({
    code: z.literal('billing_operation_failed'),
    status: z.literal(502),
  }),
)

/**
 * BillingUnavailableError
 *
 * This operation is temporarily unavailable. Please try again later.
 */
export const zBillingUnavailableError = zErrorResponse.and(
  z.object({
    code: z.literal('billing_unavailable'),
    status: z.literal(503),
  }),
)

/**
 * AppNetworkAccessGroupUpdatePayload
 */
export const zAppNetworkAccessGroupUpdatePayload = z.object({
  access_points: z.array(z.enum(['mcp', 'service_api', 'trigger', 'webapp'])).max(4),
  enabled: z.boolean(),
  expected_version: z.int().gte(0),
  group_id: z.uuid().nullable(),
})

/**
 * NetworkAccessInvalidInputError
 *
 * Invalid network access group request.
 */
export const zNetworkAccessInvalidInputError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_invalid_input'),
    status: z.literal(400),
  }),
)

/**
 * NetworkAccessUnsupportedAccessPointsError
 *
 * Some access points are not supported for this app.
 */
export const zNetworkAccessUnsupportedAccessPointsError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_unsupported_access_points'),
    status: z.literal(400),
  }),
)

/**
 * PaidPlanRequiredError
 *
 * This feature requires a paid plan.
 */
export const zPaidPlanRequiredError = zErrorResponse.and(
  z.object({
    code: z.literal('paid_plan_required'),
    status: z.literal(403),
  }),
)

/**
 * NetworkAccessGroupNotFoundError
 *
 * Network access group was not found.
 */
export const zNetworkAccessGroupNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_group_not_found'),
    status: z.literal(404),
  }),
)

/**
 * NetworkAccessVersionConflictError
 *
 * The network access resource changed. Refresh it and try again.
 */
export const zNetworkAccessVersionConflictError = zErrorResponse.and(
  z.object({
    code: z.literal('network_access_version_conflict'),
    status: z.literal(409),
  }),
)

/**
 * AppNetworkAccessGroupStatusResponse
 */
export const zAppNetworkAccessGroupStatusResponse = z.object({
  available_count: z.int().gte(0),
  configured: z.boolean(),
  covered_count: z.int().gte(0),
  enabled: z.boolean(),
  entitled: z.boolean(),
})

/**
 * RedirectUrlResponse
 */
export const zRedirectUrlResponse = z.object({
  redirect_url: z.string(),
})

/**
 * MCPServerCreatePayload
 */
export const zMcpServerCreatePayload = z.object({
  description: z.string().nullish(),
  parameters: z.record(z.string(), z.unknown()),
})

/**
 * AppSiteUpdatePayload
 */
export const zAppSiteUpdatePayload = z.object({
  chat_color_theme: z.string().nullish(),
  chat_color_theme_inverted: z.boolean().nullish(),
  copyright: z.string().nullish(),
  custom_disclaimer: z.string().nullish(),
  customize_domain: z.string().nullish(),
  customize_token_strategy: z.enum(['allow', 'must', 'not_allow']).nullish(),
  default_language: z.string().nullish(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  input_placeholder: z.string().nullish(),
  privacy_policy: z.string().nullish(),
  prompt_public: z.boolean().nullish(),
  show_workflow_steps: z.boolean().nullish(),
  title: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
})

/**
 * AppSiteResponse
 */
export const zAppSiteResponse = z.object({
  app_id: z.string(),
  code: z.string().nullish(),
  copyright: z.string().nullish(),
  custom_disclaimer: z.string().nullish(),
  customize_domain: z.string().nullish(),
  customize_token_strategy: z.string(),
  default_language: z.string(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  input_placeholder: z.string().nullish(),
  privacy_policy: z.string().nullish(),
  prompt_public: z.boolean(),
  show_workflow_steps: z.boolean(),
  title: z.string(),
  use_icon_as_answer_icon: z.boolean(),
})

/**
 * AppSiteStatusPayload
 */
export const zAppSiteStatusPayload = z.object({
  enable_site: z.boolean(),
})

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

/**
 * ProviderNotSupportTextToSpeechError
 *
 * Provider does not support text to speech.
 */
export const zProviderNotSupportTextToSpeechError = zErrorResponse.and(
  z.object({
    code: z.literal('provider_not_support_text_to_speech'),
    status: z.literal(400),
  }),
)

/**
 * AppTraceResponse
 */
export const zAppTraceResponse = z.object({
  capture_agent: z.boolean().optional().default(true),
  capture_content: z.boolean().optional().default(false),
  enabled: z.boolean().optional().default(false),
  tracing_provider: z.string().nullish(),
})

/**
 * AppTracePayload
 */
export const zAppTracePayload = z.object({
  capture_agent: z.boolean().optional().default(true),
  capture_content: z.boolean().optional().default(false),
  enabled: z.boolean(),
  tracing_provider: z.string().nullish(),
})

/**
 * InvalidTracingConfigError
 *
 * The tracing configuration is invalid.
 */
export const zInvalidTracingConfigError = zErrorResponse.and(
  z.object({
    code: z.literal('invalid_tracing_config'),
    status: z.literal(400),
  }),
)

/**
 * TracingProviderUnavailableError
 *
 * The tracing provider is not available in this deployment.
 */
export const zTracingProviderUnavailableError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_provider_unavailable'),
    status: z.literal(400),
  }),
)

/**
 * UnsupportedTracingProviderError
 *
 * The tracing provider is not supported.
 */
export const zUnsupportedTracingProviderError = zErrorResponse.and(
  z.object({
    code: z.literal('unsupported_tracing_provider'),
    status: z.literal(400),
  }),
)

/**
 * TraceConfigNotFoundError
 *
 * Tracing configuration not found.
 */
export const zTraceConfigNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('trace_config_not_found'),
    status: z.literal(404),
  }),
)

/**
 * TracingConfigConflictError
 *
 * Tracing configuration changed. Refresh and try again.
 */
export const zTracingConfigConflictError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_config_conflict'),
    status: z.literal(409),
  }),
)

/**
 * TracingConfigProcessingFailedError
 *
 * The tracing configuration could not be processed.
 */
export const zTracingConfigProcessingFailedError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_config_processing_failed'),
    status: z.literal(500),
  }),
)

/**
 * TraceProviderCapabilitiesResponse
 */
export const zTraceProviderCapabilitiesResponse = z.object({
  agent_spans: z.boolean(),
  api_collection_enabled: z.boolean(),
  export_ack: z.literal('accepted'),
  native_cost: z.boolean(),
  native_usage: z.boolean(),
  provider: z.string(),
  session: z.boolean(),
  span_url: z.boolean(),
  trace_url: z.boolean(),
})

/**
 * TraceAppConfigResponse
 */
export const zTraceAppConfigResponse = z.object({
  app_id: z.string().nullish(),
  configured_secrets: z.array(z.string()).nullish(),
  created_at: z.string().nullish(),
  error: z.string().nullish(),
  has_not_configured: z.boolean().nullish(),
  id: z.string().nullish(),
  is_active: z.boolean().nullish(),
  result: z.string().nullish(),
  tracing_config: z.record(z.string(), z.string().nullable()).nullish(),
  tracing_provider: z.string().nullish(),
  updated_at: z.string().nullish(),
})

/**
 * TraceConfigPayload
 */
export const zTraceConfigPayload = z.object({
  activate: z.boolean().optional().default(false),
  tracing_config: z.record(z.string(), z.string().nullable()),
  tracing_provider: z.string(),
})

/**
 * TracingConfigVerificationFailedError
 *
 * The tracing configuration could not be verified.
 */
export const zTracingConfigVerificationFailedError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_config_verification_failed'),
    status: z.literal(400),
  }),
)

/**
 * TraceConfigAlreadyExistsError
 *
 * A tracing configuration already exists for this provider.
 */
export const zTraceConfigAlreadyExistsError = zErrorResponse.and(
  z.object({
    code: z.literal('trace_config_already_exists'),
    status: z.literal(409),
  }),
)

/**
 * TracingNodeNotFoundError
 *
 * The Agent node invocation does not belong to this trace.
 */
export const zTracingNodeNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_node_not_found'),
    status: z.literal(404),
  }),
)

/**
 * TracingSourceNotFoundError
 *
 * The tracing source does not exist in this application.
 */
export const zTracingSourceNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_source_not_found'),
    status: z.literal(404),
  }),
)

/**
 * TraceRunRetryPayload
 */
export const zTraceRunRetryPayload = z.object({
  acknowledge_possible_duplicates: z.boolean().optional().default(false),
})

/**
 * TracingRunNotFoundError
 *
 * No collected trace is available to retry.
 */
export const zTracingRunNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_run_not_found'),
    status: z.literal(404),
  }),
)

/**
 * TracingAlreadyAcceptedError
 *
 * An accepted trace cannot be exported again.
 */
export const zTracingAlreadyAcceptedError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_already_accepted'),
    status: z.literal(409),
  }),
)

/**
 * TracingDuplicateAcknowledgementRequiredError
 *
 * Acknowledge possible duplicates before retrying an uncertain export.
 */
export const zTracingDuplicateAcknowledgementRequiredError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_duplicate_acknowledgement_required'),
    status: z.literal(409),
  }),
)

/**
 * TracingRetryNotAllowedError
 *
 * This trace is not in a retryable state.
 */
export const zTracingRetryNotAllowedError = zErrorResponse.and(
  z.object({
    code: z.literal('tracing_retry_not_allowed'),
    status: z.literal(409),
  }),
)

/**
 * ParserEnable
 */
export const zParserEnable = z.object({
  enable_trigger: z.boolean(),
  trigger_id: z.string(),
})

/**
 * WorkflowTriggerResponse
 */
export const zWorkflowTriggerResponse = z.object({
  created_at: z.iso.datetime().nullish(),
  icon: z.string(),
  id: z.string(),
  node_id: z.string(),
  provider_name: z.string(),
  status: z.string(),
  title: z.string(),
  trigger_type: z.string(),
  updated_at: z.iso.datetime().nullish(),
})

/**
 * AppTriggerNotFoundError
 *
 * Trigger not found.
 */
export const zAppTriggerNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('app_trigger_not_found'),
    status: z.literal(404),
  }),
)

/**
 * WorkflowTriggerListResponse
 */
export const zWorkflowTriggerListResponse = z.object({
  data: z.array(zWorkflowTriggerResponse),
})

/**
 * NoActiveBindingError
 *
 * No active sandbox binding.
 */
export const zNoActiveBindingError = zErrorResponse.and(
  z.object({
    code: z.literal('no_active_binding'),
    status: z.literal(404),
  }),
)

/**
 * AgentBackendUnreachableError
 *
 * Agent backend is unreachable.
 */
export const zAgentBackendUnreachableError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_backend_unreachable'),
    status: z.literal(502),
  }),
)

/**
 * InspectorUnavailableError
 *
 * Sandbox inspector is unavailable.
 */
export const zInspectorUnavailableError = zErrorResponse.and(
  z.object({
    code: z.literal('inspector_unavailable'),
    status: z.literal(503),
  }),
)

/**
 * WorkflowAgentSandboxDownloadPayload
 */
export const zWorkflowAgentSandboxDownloadPayload = z.object({
  node_execution_id: z.string().min(1),
  path: z.string().min(1),
})

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

/**
 * BindingFileDownloadUnavailableError
 *
 * Sandbox file download is unavailable.
 */
export const zBindingFileDownloadUnavailableError = zErrorResponse.and(
  z.object({
    code: z.literal('binding_file_download_unavailable'),
    status: z.literal(502),
  }),
)

/**
 * SandboxReadResponse
 */
export const zSandboxReadResponse = z.object({
  binary: z.boolean(),
  path: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * ForbiddenError
 *
 * You don't have the permission to access the requested resource.
 */
export const zForbiddenError = zErrorResponse.and(
  z.object({
    code: z.literal('forbidden'),
    status: z.literal(403),
  }),
)

/**
 * WorkflowCommentCreatePayload
 */
export const zWorkflowCommentCreatePayload = z.object({
  content: z.string(),
  mentioned_user_ids: z.array(z.string()).optional(),
  position_x: z.number(),
  position_y: z.number(),
})

/**
 * WorkflowCommentCreate
 */
export const zWorkflowCommentCreate = z.object({
  created_at: z.int().nullish(),
  id: z.string(),
})

/**
 * WorkflowCommentUpdatePayload
 */
export const zWorkflowCommentUpdatePayload = z.object({
  content: z.string(),
  mentioned_user_ids: z.array(z.string()).nullish(),
  position_x: z.number().nullish(),
  position_y: z.number().nullish(),
})

/**
 * WorkflowCommentUpdate
 */
export const zWorkflowCommentUpdate = z.object({
  id: z.string(),
  updated_at: z.int().nullish(),
})

/**
 * WorkflowCommentReplyPayload
 */
export const zWorkflowCommentReplyPayload = z.object({
  content: z.string(),
  mentioned_user_ids: z.array(z.string()).optional(),
})

/**
 * WorkflowCommentReplyCreate
 */
export const zWorkflowCommentReplyCreate = z.object({
  created_at: z.int().nullish(),
  id: z.string(),
})

/**
 * WorkflowCommentReplyUpdate
 */
export const zWorkflowCommentReplyUpdate = z.object({
  id: z.string(),
  updated_at: z.int().nullish(),
})

/**
 * WorkflowCommentResolve
 */
export const zWorkflowCommentResolve = z.object({
  id: z.string(),
  resolved: z.boolean(),
  resolved_at: z.int().nullish(),
  resolved_by: z.string().nullish(),
})

/**
 * DefaultBlockConfigResponse
 */
export const zDefaultBlockConfigResponse = z.record(z.string(), z.unknown())

/**
 * DraftWorkflowNotExistError
 *
 * Draft workflow need to be initialized.
 */
export const zDraftWorkflowNotExistError = zErrorResponse.and(
  z.object({
    code: z.literal('draft_workflow_not_exist'),
    status: z.literal(404),
  }),
)

/**
 * SyncDraftWorkflowResponse
 */
export const zSyncDraftWorkflowResponse = z.object({
  hash: z.string(),
  result: z.string(),
  updated_at: z.int(),
})

/**
 * DraftWorkflowNotSyncError
 *
 * Workflow graph might have been modified, please refresh and resubmit.
 */
export const zDraftWorkflowNotSyncError = zErrorResponse.and(
  z.object({
    code: z.literal('draft_workflow_not_sync'),
    status: z.literal(409),
  }),
)

/**
 * HumanInputDeliveryTestPayload
 */
export const zHumanInputDeliveryTestPayload = z.object({
  delivery_method_id: z.string(),
  inputs: z.record(z.string(), z.unknown()).optional(),
})

/**
 * EmptyObjectResponse
 */
export const zEmptyObjectResponse = z.record(z.string(), z.unknown())

/**
 * AgentSoulLockedError
 *
 * Agent Soul is locked for this workflow node.
 */
export const zAgentSoulLockedError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_soul_locked_error'),
    status: z.literal(400),
  }),
)

/**
 * InvalidComposerConfigError
 *
 * Invalid agent composer config.
 */
export const zInvalidComposerConfigError = zErrorResponse.and(
  z.object({
    code: z.literal('invalid_composer_config_error'),
    status: z.literal(400),
  }),
)

/**
 * PlaintextSecretNotAllowedError
 *
 * Plaintext secret values are not allowed in Agent config.
 */
export const zPlaintextSecretNotAllowedError = zErrorResponse.and(
  z.object({
    code: z.literal('plaintext_secret_not_allowed_error'),
    status: z.literal(400),
  }),
)

/**
 * WorkflowComposerCopyFromRosterPayload
 */
export const zWorkflowComposerCopyFromRosterPayload = z.object({
  idempotency_key: z.string().max(255).nullish(),
  source_agent_id: z.string().min(1).max(255),
  source_snapshot_id: z.string().max(255).nullish(),
})

/**
 * AgentVersionConflictError
 *
 * Agent config version changed. Please reload and try again.
 */
export const zAgentVersionConflictError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_version_conflict_error'),
    status: z.literal(409),
  }),
)

/**
 * DraftWorkflowNodeRunPayload
 */
export const zDraftWorkflowNodeRunPayload = z.object({
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  inputs: z.record(z.string(), z.unknown()),
  query: z.string().optional().default(''),
})

/**
 * WorkflowTriggerRunErrorResponse
 *
 * 400 body when a draft trigger run fails; ``error`` is omitted when there is nothing user-facing to say.
 */
export const zWorkflowTriggerRunErrorResponse = z.object({
  error: z.string().optional(),
  status: z.literal('error'),
})

/**
 * DraftWorkflowRunPayload
 */
export const zDraftWorkflowRunPayload = z.object({
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  inputs: z.record(z.string(), z.unknown()),
})

/**
 * WorkflowRunNotFoundError
 *
 * Workflow run not found.
 */
export const zWorkflowRunNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('workflow_run_not_found'),
    status: z.literal(404),
  }),
)

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

/**
 * NodeNotInWorkflowRunError
 *
 * The node is not part of this workflow run.
 */
export const zNodeNotInWorkflowRunError = zErrorResponse.and(
  z.object({
    code: z.literal('node_not_in_workflow_run'),
    status: z.literal(404),
  }),
)

/**
 * NodeOutputNotDeclaredError
 *
 * The node does not declare this output.
 */
export const zNodeOutputNotDeclaredError = zErrorResponse.and(
  z.object({
    code: z.literal('node_output_not_declared'),
    status: z.literal(404),
  }),
)

/**
 * DraftWorkflowTriggerRunPayload
 */
export const zDraftWorkflowTriggerRunPayload = z.object({
  node_id: z.string(),
})

/**
 * DraftWorkflowTriggerRunAllPayload
 */
export const zDraftWorkflowTriggerRunAllPayload = z.object({
  node_ids: z.array(z.string()),
})

/**
 * WorkflowDraftVariableUpdatePayload
 */
export const zWorkflowDraftVariableUpdatePayload = z.object({
  name: z.string().nullish(),
  value: z.unknown().nullish(),
})

/**
 * PublishWorkflowPayload
 */
export const zPublishWorkflowPayload = z.object({
  marked_comment: z.string().max(100).nullish(),
  marked_name: z.string().max(20).nullish(),
})

/**
 * WorkflowPublishResponse
 */
export const zWorkflowPublishResponse = z.object({
  created_at: z.int(),
  result: z.string(),
  warning: z.string().nullish(),
})

/**
 * WebhookTriggerResponse
 */
export const zWebhookTriggerResponse = z.object({
  created_at: z.iso.datetime().nullish(),
  id: z.string(),
  node_id: z.string(),
  webhook_debug_url: z.string(),
  webhook_id: z.string(),
  webhook_url: z.string(),
})

/**
 * WebhookTriggerNotFoundError
 *
 * Webhook trigger not found for this node.
 */
export const zWebhookTriggerNotFoundError = zErrorResponse.and(
  z.object({
    code: z.literal('webhook_trigger_not_found'),
    status: z.literal(404),
  }),
)

/**
 * WorkflowUpdatePayload
 */
export const zWorkflowUpdatePayload = z.object({
  marked_comment: z.string().max(100).nullish(),
  marked_name: z.string().max(20).nullish(),
})

/**
 * WorkflowRestoreResponse
 */
export const zWorkflowRestoreResponse = z.object({
  hash: z.string(),
  result: z.string(),
  updated_at: z.int(),
})

/**
 * ApiKeyItem
 */
export const zApiKeyItem = z.object({
  created_at: z.int().nullish(),
  dataset_ids: z.array(z.string()).optional().default([]),
  id: z.string(),
  knowledge_space_ids: z.array(z.string()).optional().default([]),
  last_used_at: z.int().nullish(),
  token: z.string(),
  type: z.string(),
})

/**
 * ApiKeyList
 */
export const zApiKeyList = z.object({
  data: z.array(zApiKeyItem),
})

/**
 * MaxKeysExceededError
 *
 * The API key limit has been reached.
 */
export const zMaxKeysExceededError = zErrorResponse.and(
  z.object({
    code: z.literal('max_keys_exceeded'),
    status: z.literal(400),
  }),
)

/**
 * AgentNotPublishedError
 *
 * Publish the Agent before enabling Web App or API access.
 */
export const zAgentNotPublishedError = zErrorResponse.and(
  z.object({
    code: z.literal('agent_not_published'),
    status: z.literal(409),
  }),
)

/**
 * IconType
 */
export const zIconType = z.enum(['emoji', 'image', 'link'])

/**
 * CreateAppPayload
 */
export const zCreateAppPayload = z.object({
  description: z.string().max(400).nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  mode: z.enum(['advanced-chat', 'agent-chat', 'chat', 'completion', 'workflow']),
  name: z.string().min(1),
})

/**
 * UpdateAppPayload
 */
export const zUpdateAppPayload = z.object({
  description: z.string().max(400).nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  max_active_requests: z.int().nullish(),
  name: z.string().min(1),
  use_icon_as_answer_icon: z.boolean().nullish(),
})

/**
 * CopyAppPayload
 */
export const zCopyAppPayload = z.object({
  description: z.string().max(400).nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  name: z.string().nullish(),
})

/**
 * AppIconPayload
 */
export const zAppIconPayload = z.object({
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
})

/**
 * WebAppAccessMode
 */
export const zWebAppAccessMode = z.enum(['private', 'private_all', 'public', 'sso_verified'])

/**
 * DeletedTool
 */
export const zDeletedTool = z.object({
  provider_id: z.string(),
  tool_name: z.string(),
  type: z.string(),
})

/**
 * AppMode
 */
export const zAppMode = z.enum([
  'advanced-chat',
  'agent',
  'agent-chat',
  'channel',
  'chat',
  'completion',
  'rag-pipeline',
  'workflow',
])

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

/**
 * WorkflowPartial
 */
export const zWorkflowPartial = z.object({
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  id: z.string(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
})

/**
 * ImportStatus
 */
export const zImportStatus = z.enum(['completed', 'completed-with-warnings', 'failed', 'pending'])

/**
 * DslImportWarning
 *
 * Portable DSL reference that could not be restored in the target workspace.
 */
export const zDslImportWarning = z.object({
  code: z.string(),
  details: z.record(z.string(), z.unknown()).optional(),
  message: z.string(),
  path: z.string(),
})

/**
 * Import
 */
export const zImport = z.object({
  app_id: z.string().nullish(),
  app_mode: zAppMode.nullish(),
  current_dsl_version: z.string().optional().default('0.7.0'),
  error: z.string().optional().default(''),
  id: z.string(),
  imported_dsl_version: z.string().optional().default(''),
  permission_keys: z.array(z.string()).optional(),
  status: zImportStatus,
  warnings: z.array(zDslImportWarning).optional(),
})

/**
 * AppImportResponse
 */
export const zAppImportResponse = z.object({
  app_id: z.string().nullish(),
  app_mode: zAppMode.nullish(),
  current_dsl_version: z.string(),
  error: z.string().optional().default(''),
  id: z.string(),
  imported_dsl_version: z.string().optional().default(''),
  status: zImportStatus,
  warnings: z.array(zDslImportWarning).optional(),
})

/**
 * RecentAppResponse
 */
export const zRecentAppResponse = z.object({
  author_name: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  icon_url: z.string().nullable(),
  id: z.string(),
  maintainer: z.string().nullish(),
  mode: z.enum(['advanced-chat', 'agent-chat', 'chat', 'completion', 'workflow']),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  updated_at: z.int(),
})

/**
 * RecentAppListResponse
 */
export const zRecentAppListResponse = z.object({
  data: z.array(zRecentAppResponse),
})

/**
 * DebugChannel
 *
 * Delivery selection for editor debugging, resolved to current channel configuration.
 */
export const zDebugChannel = z.enum([
  'ding_talk',
  'email',
  'feishu',
  'lark',
  'ms_teams',
  'slack',
  'we_com',
])

export const zJsonValue = z.unknown()

/**
 * MessageTemplateTestRequest
 *
 * Request body for sending one message-template test notification.
 */
export const zMessageTemplateTestRequest = z.object({
  channel: zDebugChannel,
  inputs: z.record(z.string(), zJsonValue).optional(),
})

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

/**
 * GeneratedAppResponse
 */
export const zGeneratedAppResponse = zShallowJsonValue

/**
 * AgentConfigVersionResponse
 */
export const zAgentConfigVersionResponse = z.object({
  id: z.string(),
  kind: z.enum(['build_draft', 'draft', 'snapshot']),
  writable: z.boolean(),
})

/**
 * AgentConfigFileItemResponse
 */
export const zAgentConfigFileItemResponse = z.object({
  file_id: z.string().nullish(),
  hash: z.string().nullish(),
  id: z.string(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
})

/**
 * AgentConfigFileListResponse
 */
export const zAgentConfigFileListResponse = z.object({
  agent_id: z.string(),
  config_version: zAgentConfigVersionResponse,
  items: z.array(zAgentConfigFileItemResponse).optional(),
})

/**
 * AgentConfigFileUploadResponse
 */
export const zAgentConfigFileUploadResponse = z.object({
  config_version: zAgentConfigVersionResponse,
  file: zAgentConfigFileItemResponse,
})

/**
 * AgentConfigFilesUploadResponse
 */
export const zAgentConfigFilesUploadResponse = z.object({
  config_version: zAgentConfigVersionResponse,
  files: z.array(zAgentConfigFileItemResponse),
})

/**
 * AgentConfigFileItemsResponse
 */
export const zAgentConfigFileItemsResponse = z.object({
  items: z.array(zAgentConfigFileItemResponse).optional(),
})

/**
 * AgentConfigSkillItemResponse
 */
export const zAgentConfigSkillItemResponse = z.object({
  description: z.string().optional().default(''),
  file_id: z.string().nullish(),
  hash: z.string().nullish(),
  id: z.string(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
})

/**
 * AgentConfigSkillListResponse
 */
export const zAgentConfigSkillListResponse = z.object({
  agent_id: z.string(),
  config_version: zAgentConfigVersionResponse,
  items: z.array(zAgentConfigSkillItemResponse).optional(),
})

/**
 * AgentConfigSkillUploadResponse
 */
export const zAgentConfigSkillUploadResponse = z.object({
  config_version: zAgentConfigVersionResponse,
  skill: zAgentConfigSkillItemResponse,
})

/**
 * AgentConfigSkillItemsResponse
 */
export const zAgentConfigSkillItemsResponse = z.object({
  items: z.array(zAgentConfigSkillItemResponse).optional(),
})

/**
 * AgentConfigManifestResponse
 */
export const zAgentConfigManifestResponse = z.object({
  agent_id: z.string(),
  config_version: zAgentConfigVersionResponse,
  env_keys: z.array(z.string()).optional(),
  files: zAgentConfigFileItemsResponse.optional(),
  note: z.string().optional().default(''),
  skills: zAgentConfigSkillItemsResponse.optional(),
})

/**
 * AgentConfigSkillFileResponse
 */
export const zAgentConfigSkillFileResponse = z.object({
  downloadable: z.boolean(),
  name: z.string(),
  path: z.string(),
  previewable: z.boolean(),
  type: z.enum(['directory', 'file']),
})

/**
 * AgentConfigSkillMarkdownResponse
 */
export const zAgentConfigSkillMarkdownResponse = z.object({
  binary: z.literal(false),
  path: z.literal('SKILL.md'),
  size: z.int().nullish(),
  text: z.string(),
  truncated: z.boolean(),
})

/**
 * AgentConfigSkillInspectResponse
 */
export const zAgentConfigSkillInspectResponse = z.object({
  description: z.string().optional().default(''),
  file_tree: z.array(z.record(z.string(), z.unknown())).nullish(),
  files: z.array(zAgentConfigSkillFileResponse).optional(),
  hash: z.string().nullish(),
  id: z.string(),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
  skill_md: zAgentConfigSkillMarkdownResponse,
  source: z.literal('config_skill_zip'),
  warnings: z.array(z.string()).optional(),
})

/**
 * AgentLogMetaResponse
 */
export const zAgentLogMetaResponse = z.object({
  agent_mode: z.string(),
  elapsed_time: z.number().nullish(),
  executor: z.string(),
  iterations: z.int(),
  start_time: z.string(),
  status: z.string(),
  total_tokens: z.int(),
})

/**
 * AnnotationSettingEmbeddingModelResponse
 */
export const zAnnotationSettingEmbeddingModelResponse = z.object({
  embedding_model_name: z.string().nullish(),
  embedding_provider_name: z.string().nullish(),
})

/**
 * AnnotationSettingResponse
 */
export const zAnnotationSettingResponse = z.object({
  embedding_model: zAnnotationSettingEmbeddingModelResponse.nullish(),
  enabled: z.boolean(),
  id: z.string().nullish(),
  score_threshold: z.number().nullish(),
})

/**
 * AnnotationHitHistory
 */
export const zAnnotationHitHistory = z.object({
  created_at: z.int().nullish(),
  id: z.string(),
  match: z.string().nullish(),
  question: z.string().nullish(),
  response: z.string().nullish(),
  score: z.number().nullish(),
  source: z.string().nullish(),
})

/**
 * AnnotationHitHistoryList
 */
export const zAnnotationHitHistoryList = z.object({
  data: z.array(zAnnotationHitHistory),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * FeedbackStat
 */
export const zFeedbackStat = z.object({
  dislike: z.int(),
  like: z.int(),
})

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

/**
 * PaginatedConversationVariableResponse
 */
export const zPaginatedConversationVariableResponse = z.object({
  data: z.array(zConversationVariableResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

export const zAnyJsonValue = z.unknown()

/**
 * ConversationModelConfig
 */
export const zConversationModelConfig = z.object({
  agent_mode: zAnyJsonValue.nullish(),
  model: zAnyJsonValue.nullish(),
  opening_statement: z.string().nullish(),
  pre_prompt: z.string().nullish(),
  suggested_questions: zAnyJsonValue.nullish(),
  user_input_form: zAnyJsonValue.nullish(),
})

/**
 * ConversationDetail
 */
export const zConversationDetail = z.object({
  admin_feedback_stats: zFeedbackStat.nullish(),
  annotated: z.boolean(),
  created_at: z.int().nullish(),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  introduction: z.string().nullish(),
  message_count: z.int(),
  model_config: zConversationModelConfig.nullish(),
  status: z.string(),
  updated_at: z.int().nullish(),
  user_feedback_stats: zFeedbackStat.nullish(),
})

/**
 * AgentThought
 */
export const zAgentThought = z.object({
  answer: z.string().nullish(),
  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: zAnyJsonValue,
})

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

/**
 * AppNetworkAccessGroupBindingResponse
 */
export const zAppNetworkAccessGroupBindingResponse = z.object({
  access_points: z.array(z.enum(['mcp', 'service_api', 'trigger', 'webapp'])).max(4),
  app_id: z.string(),
  created_at: z.iso.datetime(),
  enabled: z.boolean(),
  group_id: z.string().nullish(),
  id: z.string(),
  tenant_id: z.string(),
  updated_at: z.iso.datetime(),
  updated_by_account_id: z.string().nullish(),
  version: z.int().gte(1),
})

/**
 * AppNetworkAccessGroupResponse
 */
export const zAppNetworkAccessGroupResponse = z.object({
  app_id: z.string(),
  available_access_points: z.array(z.enum(['mcp', 'service_api', 'trigger', 'webapp'])),
  binding: zAppNetworkAccessGroupBindingResponse.nullable(),
  effective_enabled: z.boolean(),
  entitled: z.boolean(),
  tenant_id: z.string(),
})

/**
 * AppNetworkAccessGroupMutationResponse
 */
export const zAppNetworkAccessGroupMutationResponse = z.object({
  available_access_points: z.array(z.enum(['mcp', 'service_api', 'trigger', 'webapp'])),
  binding: zAppNetworkAccessGroupBindingResponse,
  effective_enabled: z.boolean(),
})

/**
 * AppMCPServerStatus
 *
 * Publication state of a Dify app exposed as an MCP server; only ACTIVE servers accept MCP calls.
 */
export const zAppMcpServerStatus = z.enum(['active', 'inactive', 'normal'])

/**
 * AppMCPServerResponse
 */
export const zAppMcpServerResponse = z.object({
  created_at: z.int().nullish(),
  description: z.string(),
  id: z.string(),
  name: z.string(),
  parameters: z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string()]),
  server_code: z.string(),
  status: zAppMcpServerStatus,
  updated_at: z.int().nullish(),
})

/**
 * MCPServerUpdatePayload
 */
export const zMcpServerUpdatePayload = z.object({
  description: z.string().nullish(),
  id: z.uuid(),
  parameters: z.record(z.string(), z.unknown()),
  status: zAppMcpServerStatus.nullish(),
})

/**
 * AverageResponseTimeStatisticItem
 */
export const zAverageResponseTimeStatisticItem = z.object({
  date: z.string(),
  latency: z.number(),
})

/**
 * AverageResponseTimeStatisticResponse
 */
export const zAverageResponseTimeStatisticResponse = z.object({
  data: z.array(zAverageResponseTimeStatisticItem),
})

/**
 * AverageSessionInteractionStatisticItem
 */
export const zAverageSessionInteractionStatisticItem = z.object({
  date: z.string(),
  interactions: z.number(),
})

/**
 * AverageSessionInteractionStatisticResponse
 */
export const zAverageSessionInteractionStatisticResponse = z.object({
  data: z.array(zAverageSessionInteractionStatisticItem),
})

/**
 * DailyConversationStatisticItem
 */
export const zDailyConversationStatisticItem = z.object({
  conversation_count: z.int(),
  date: z.string(),
})

/**
 * DailyConversationStatisticResponse
 */
export const zDailyConversationStatisticResponse = z.object({
  data: z.array(zDailyConversationStatisticItem),
})

/**
 * DailyTerminalStatisticItem
 */
export const zDailyTerminalStatisticItem = z.object({
  date: z.string(),
  terminal_count: z.int(),
})

/**
 * DailyTerminalStatisticResponse
 */
export const zDailyTerminalStatisticResponse = z.object({
  data: z.array(zDailyTerminalStatisticItem),
})

/**
 * DailyMessageStatisticItem
 */
export const zDailyMessageStatisticItem = z.object({
  date: z.string(),
  message_count: z.int(),
})

/**
 * DailyMessageStatisticResponse
 */
export const zDailyMessageStatisticResponse = z.object({
  data: z.array(zDailyMessageStatisticItem),
})

/**
 * DailyTokenCostStatisticItem
 */
export const zDailyTokenCostStatisticItem = z.object({
  currency: z.string().nullish(),
  date: z.string(),
  token_count: z.int().nullish(),
  total_price: z
    .string()
    .regex(/^(?![-+.]*$)[+-]?0*\d*\.?\d*$/)
    .nullish(),
})

/**
 * DailyTokenCostStatisticResponse
 */
export const zDailyTokenCostStatisticResponse = z.object({
  data: z.array(zDailyTokenCostStatisticItem),
})

/**
 * TokensPerSecondStatisticItem
 */
export const zTokensPerSecondStatisticItem = z.object({
  date: z.string(),
  tps: z.number(),
})

/**
 * TokensPerSecondStatisticResponse
 */
export const zTokensPerSecondStatisticResponse = z.object({
  data: z.array(zTokensPerSecondStatisticItem),
})

/**
 * UserSatisfactionRateStatisticItem
 */
export const zUserSatisfactionRateStatisticItem = z.object({
  date: z.string(),
  rate: z.number(),
})

/**
 * UserSatisfactionRateStatisticResponse
 */
export const zUserSatisfactionRateStatisticResponse = z.object({
  data: z.array(zUserSatisfactionRateStatisticItem),
})

/**
 * TextToSpeechVoiceResponse
 */
export const zTextToSpeechVoiceResponse = z.object({
  name: z.string(),
  value: z.string(),
})

/**
 * TextToSpeechVoiceListResponse
 *
 * Available voices
 */
export const zTextToSpeechVoiceListResponse = z.array(zTextToSpeechVoiceResponse)

/**
 * TraceProviderSupportResponse
 *
 * Adapter support declarations, not successful-delivery or platform-verification results.
 */
export const zTraceProviderSupportResponse = z.object({
  agent_spans: z.boolean(),
  export_ack: z.literal('accepted'),
  native_cost: z.boolean(),
  native_usage: z.boolean(),
  provider: z.string(),
  session: z.boolean(),
  span_url: z.boolean(),
  trace_url: z.boolean(),
})

export const zTraceSourceKind = z.enum(['message', 'node', 'workflow'])

/**
 * TraceRunStatusResponse
 */
export const zTraceRunStatusResponse = z.object({
  accepted_at: z.iso.datetime().nullish(),
  attempts: z.int().nullish(),
  capabilities: zTraceProviderSupportResponse.nullish(),
  capture_agent: z.boolean().nullish(),
  capture_content: z.boolean().nullish(),
  config_revision: z.string().nullish(),
  error_code: z.string().nullish(),
  project_url: z.string().nullish(),
  provider: z.string().nullish(),
  queryable: z.boolean().nullish(),
  source_id: z.string(),
  source_kind: zTraceSourceKind,
  span_count: z.int().nullish(),
  span_url: z.string().nullish(),
  status: z.enum([
    'accepted',
    'collecting',
    'exporting',
    'failed',
    'not_collected',
    'ready',
    'retrying',
    'uncertain',
  ]),
  trace_id: z.string().nullish(),
  trace_url: z.string().nullish(),
})

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

/**
 * AdvancedChatWorkflowRunForListResponse
 */
export const zAdvancedChatWorkflowRunForListResponse = z.object({
  conversation_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by_account: zSimpleAccountResponse.nullish(),
  elapsed_time: z.number().nullish(),
  exceptions_count: z.int().nullish(),
  finished_at: z.int().nullish(),
  id: z.string(),
  message_id: z.string().nullish(),
  retry_index: z.int().nullish(),
  status: z.string().nullish(),
  total_steps: z.int().nullish(),
  total_tokens: z.int().nullish(),
  version: z.string().nullish(),
})

/**
 * AdvancedChatWorkflowRunPaginationResponse
 */
export const zAdvancedChatWorkflowRunPaginationResponse = z.object({
  data: z.array(zAdvancedChatWorkflowRunForListResponse),
  has_more: z.boolean(),
  limit: z.int(),
})

/**
 * WorkflowRunForListResponse
 */
export const zWorkflowRunForListResponse = z.object({
  created_at: z.int().nullish(),
  created_by_account: zSimpleAccountResponse.nullish(),
  elapsed_time: z.number().nullish(),
  exceptions_count: z.int().nullish(),
  finished_at: z.int().nullish(),
  id: z.string(),
  retry_index: z.int().nullish(),
  status: z.string().nullish(),
  total_steps: z.int().nullish(),
  total_tokens: z.int().nullish(),
  version: z.string().nullish(),
})

/**
 * WorkflowRunPaginationResponse
 */
export const zWorkflowRunPaginationResponse = z.object({
  data: z.array(zWorkflowRunForListResponse),
  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(),
})

/**
 * WorkflowRunDetailResponse
 */
export const zWorkflowRunDetailResponse = z.object({
  created_at: z.int().nullish(),
  created_by_account: zSimpleAccountResponse.nullish(),
  created_by_end_user: zSimpleEndUser.nullish(),
  created_by_role: z.string().nullish(),
  elapsed_time: z.number().nullish(),
  error: z.string().nullish(),
  exceptions_count: z.int().nullish(),
  finished_at: z.int().nullish(),
  graph: z.unknown(),
  id: z.string(),
  inputs: z.unknown(),
  outputs: z.unknown(),
  status: z.string().nullish(),
  total_steps: z.int().nullish(),
  total_tokens: z.int().nullish(),
  version: z.string().nullish(),
})

/**
 * WorkflowRunNodeExecutionResponse
 */
export const zWorkflowRunNodeExecutionResponse = z.object({
  created_at: z.int().nullish(),
  created_by_account: zSimpleAccountResponse.nullish(),
  created_by_end_user: zSimpleEndUser.nullish(),
  created_by_role: z.string().nullish(),
  elapsed_time: z.number().nullish(),
  error: z.string().nullish(),
  execution_metadata: z.unknown().optional(),
  extras: z.unknown().optional(),
  finished_at: z.int().nullish(),
  id: z.string(),
  index: z.int().nullish(),
  inputs: z.unknown().optional(),
  inputs_truncated: z.boolean().nullish(),
  node_id: z.string().nullish(),
  node_type: z.string().nullish(),
  outputs: z.unknown().optional(),
  outputs_truncated: z.boolean().nullish(),
  predecessor_node_id: z.string().nullish(),
  process_data: z.unknown().optional(),
  process_data_truncated: z.boolean().nullish(),
  retry_index: z.int().nullish(),
  status: z.string().nullish(),
  title: z.string().nullish(),
})

/**
 * WorkflowRunNodeExecutionListResponse
 */
export const zWorkflowRunNodeExecutionListResponse = z.object({
  data: z.array(zWorkflowRunNodeExecutionResponse),
})

/**
 * WorkflowToolNodeExecutionResponse
 */
export const zWorkflowToolNodeExecutionResponse = z.object({
  created_at: z.int().nullish(),
  created_by_account: zSimpleAccountResponse.nullish(),
  created_by_end_user: zSimpleEndUser.nullish(),
  created_by_role: z.string().nullish(),
  elapsed_time: z.number().nullish(),
  error: z.string().nullish(),
  execution_metadata: z.unknown().optional(),
  extras: z.unknown().optional(),
  finished_at: z.int().nullish(),
  id: z.string(),
  index: z.int().nullish(),
  inputs: z.unknown().optional(),
  inputs_truncated: z.boolean().nullish(),
  node_execution_id: z.string().nullish(),
  node_id: z.string().nullish(),
  node_type: z.string().nullish(),
  outputs: z.unknown().optional(),
  outputs_truncated: z.boolean().nullish(),
  predecessor_node_id: z.string().nullish(),
  process_data: z.unknown().optional(),
  process_data_truncated: z.boolean().nullish(),
  retry_index: z.int().nullish(),
  status: z.string().nullish(),
  title: z.string().nullish(),
})

/**
 * WorkflowToolNodeExecutionListResponse
 */
export const zWorkflowToolNodeExecutionListResponse = z.object({
  data: z.array(zWorkflowToolNodeExecutionResponse),
})

/**
 * SandboxFileEntryResponse
 */
export const zSandboxFileEntryResponse = z.object({
  mtime: z.int().nullish(),
  name: z.string(),
  size: z.int().nullish(),
  type: z.enum(['dir', 'file', 'other', 'symlink']),
})

/**
 * SandboxListResponse
 */
export const zSandboxListResponse = z.object({
  entries: z.array(zSandboxFileEntryResponse).optional(),
  path: z.string(),
  truncated: z.boolean().optional().default(false),
})

/**
 * WorkflowCommentAccount
 */
export const zWorkflowCommentAccount = z.object({
  avatar_url: z.string().nullable(),
  email: z.string(),
  id: z.string(),
  name: z.string(),
})

/**
 * WorkflowCommentBasic
 */
export const zWorkflowCommentBasic = z.object({
  content: z.string(),
  created_at: z.int().nullish(),
  created_by: z.string(),
  created_by_account: zWorkflowCommentAccount.nullish(),
  id: z.string(),
  mention_count: z.int(),
  participants: z.array(zWorkflowCommentAccount),
  position_x: z.number(),
  position_y: z.number(),
  reply_count: z.int(),
  resolved: z.boolean(),
  resolved_at: z.int().nullish(),
  resolved_by: z.string().nullish(),
  resolved_by_account: zWorkflowCommentAccount.nullish(),
  updated_at: z.int().nullish(),
})

/**
 * WorkflowCommentBasicList
 */
export const zWorkflowCommentBasicList = z.object({
  data: z.array(zWorkflowCommentBasic),
})

/**
 * WorkflowCommentMention
 */
export const zWorkflowCommentMention = z.object({
  mentioned_user_account: zWorkflowCommentAccount.nullish(),
  mentioned_user_id: z.string(),
  reply_id: z.string().nullish(),
})

/**
 * WorkflowCommentReply
 */
export const zWorkflowCommentReply = z.object({
  content: z.string(),
  created_at: z.int().nullish(),
  created_by: z.string(),
  created_by_account: zWorkflowCommentAccount.nullish(),
  id: z.string(),
})

/**
 * WorkflowCommentDetail
 */
export const zWorkflowCommentDetail = z.object({
  content: z.string(),
  created_at: z.int().nullish(),
  created_by: z.string(),
  created_by_account: zWorkflowCommentAccount.nullish(),
  id: z.string(),
  mentions: z.array(zWorkflowCommentMention),
  position_x: z.number(),
  position_y: z.number(),
  replies: z.array(zWorkflowCommentReply),
  resolved: z.boolean(),
  resolved_at: z.int().nullish(),
  resolved_by: z.string().nullish(),
  resolved_by_account: zWorkflowCommentAccount.nullish(),
  updated_at: z.int().nullish(),
})

/**
 * WorkflowAverageAppInteractionStatisticItem
 */
export const zWorkflowAverageAppInteractionStatisticItem = z.object({
  date: z.string(),
  interactions: z.number(),
})

/**
 * WorkflowAverageAppInteractionStatisticResponse
 */
export const zWorkflowAverageAppInteractionStatisticResponse = z.object({
  data: z.array(zWorkflowAverageAppInteractionStatisticItem),
})

/**
 * WorkflowDailyRunsStatisticItem
 */
export const zWorkflowDailyRunsStatisticItem = z.object({
  date: z.string(),
  runs: z.int(),
})

/**
 * WorkflowDailyRunsStatisticResponse
 */
export const zWorkflowDailyRunsStatisticResponse = z.object({
  data: z.array(zWorkflowDailyRunsStatisticItem),
})

/**
 * WorkflowDailyTerminalsStatisticItem
 */
export const zWorkflowDailyTerminalsStatisticItem = z.object({
  date: z.string(),
  terminal_count: z.int(),
})

/**
 * WorkflowDailyTerminalsStatisticResponse
 */
export const zWorkflowDailyTerminalsStatisticResponse = z.object({
  data: z.array(zWorkflowDailyTerminalsStatisticItem),
})

/**
 * WorkflowDailyTokenCostStatisticItem
 */
export const zWorkflowDailyTokenCostStatisticItem = z.object({
  date: z.string(),
  token_count: z.int(),
})

/**
 * WorkflowDailyTokenCostStatisticResponse
 */
export const zWorkflowDailyTokenCostStatisticResponse = z.object({
  data: z.array(zWorkflowDailyTokenCostStatisticItem),
})

/**
 * DefaultBlockConfigItemResponse
 */
export const zDefaultBlockConfigItemResponse = z.object({
  config: z.record(z.string(), z.unknown()),
  type: z.string(),
})

/**
 * DefaultBlockConfigsResponse
 */
export const zDefaultBlockConfigsResponse = z.array(zDefaultBlockConfigItemResponse)

/**
 * WorkflowConversationVariableResponse
 */
export const zWorkflowConversationVariableResponse = z.object({
  description: z.string(),
  id: z.string(),
  name: z.string(),
  value: z.unknown(),
  value_type: z.string(),
})

/**
 * WorkflowEnvironmentVariableResponse
 */
export const zWorkflowEnvironmentVariableResponse = z.object({
  description: z.string(),
  id: z.string(),
  name: z.string(),
  value: z.unknown(),
  value_type: z.string(),
})

/**
 * PipelineVariableResponse
 */
export const zPipelineVariableResponse = z.object({
  allowed_file_extensions: z.array(z.string()).nullish(),
  allowed_file_types: z.array(z.string()).nullish(),
  allowed_file_upload_methods: z.array(z.string()).nullish(),
  belong_to_node_id: z.string(),
  default_value: z.unknown().optional(),
  label: z.string(),
  max_length: z.int().nullish(),
  options: z.array(z.string()).nullish(),
  placeholder: z.string().nullish(),
  required: z.boolean(),
  tooltips: z.string().nullish(),
  type: z.string(),
  unit: z.string().nullish(),
  variable: z.string(),
})

/**
 * WorkflowResponse
 */
export const zWorkflowResponse = z.object({
  conversation_variables: z.array(zWorkflowConversationVariableResponse),
  created_at: z.int(),
  created_by: zSimpleAccountResponse.nullish(),
  environment_variables: z.array(zWorkflowEnvironmentVariableResponse),
  features: z.record(z.string(), z.unknown()),
  graph: z.record(z.string(), z.unknown()),
  hash: z.string(),
  id: z.string(),
  marked_comment: z.string(),
  marked_name: z.string(),
  rag_pipeline_variables: z.array(zPipelineVariableResponse),
  tool_published: z.boolean(),
  updated_at: z.int(),
  updated_by: zSimpleAccountResponse.nullish(),
  version: z.string(),
  version_number: z.int().nullish(),
})

/**
 * WorkflowPaginationResponse
 */
export const zWorkflowPaginationResponse = z.object({
  has_more: z.boolean(),
  items: z.array(zWorkflowResponse),
  limit: z.int(),
  page: z.int(),
})

/**
 * SyncEnvironmentVariablePatchPayload
 */
export const zSyncEnvironmentVariablePatchPayload = z.object({
  deleted_environment_variable_ids: z.array(z.string()).optional(),
  environment_variables: z.array(z.record(z.string(), z.unknown())).optional(),
})

/**
 * SyncDraftWorkflowPayload
 */
export const zSyncDraftWorkflowPayload = z.object({
  _is_collaborative: z.boolean().optional().default(false),
  conversation_variables: z.array(z.record(z.string(), z.unknown())).optional(),
  environment_variable_patch: zSyncEnvironmentVariablePatchPayload.nullish(),
  features: z.record(z.string(), z.unknown()),
  force: z.boolean().optional().default(false),
  graph: z.record(z.string(), z.unknown()),
  hash: z.string().nullish(),
})

/**
 * ConversationVariableItemPayload
 */
export const zConversationVariableItemPayload = z.object({
  description: z.string().nullish(),
  id: z.string().nullish(),
  name: z.string().nullish(),
  value: z.unknown().nullish(),
  value_type: z.string().nullish(),
})

/**
 * ConversationVariableUpdatePayload
 */
export const zConversationVariableUpdatePayload = z.object({
  conversation_variables: z.array(zConversationVariableItemPayload),
})

/**
 * EnvironmentVariableItemResponse
 */
export const zEnvironmentVariableItemResponse = z.object({
  description: z.string().nullish(),
  editable: z.boolean(),
  edited: z.boolean(),
  id: z.string(),
  name: z.string(),
  selector: z.array(z.string()),
  type: z.string(),
  value: z.unknown(),
  value_type: z.string(),
  visible: z.boolean(),
})

/**
 * EnvironmentVariableListResponse
 */
export const zEnvironmentVariableListResponse = z.object({
  items: z.array(zEnvironmentVariableItemResponse),
})

/**
 * EnvironmentVariableItemPayload
 */
export const zEnvironmentVariableItemPayload = z.object({
  description: z.string().nullish(),
  id: z.string().nullish(),
  name: z.string().nullish(),
  value: z.unknown().nullish(),
  value_type: z.string().nullish(),
})

/**
 * EnvironmentVariableUpdatePayload
 */
export const zEnvironmentVariableUpdatePayload = z.object({
  deleted_environment_variable_ids: z.array(z.string()).optional(),
  environment_variables: z.array(zEnvironmentVariableItemPayload),
  patch: z.boolean().optional().default(false),
})

/**
 * AgentConfigSnapshotSummaryResponse
 */
export const zAgentConfigSnapshotSummaryResponse = z.object({
  agent_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  display_version: z.int().nullish(),
  id: z.string(),
  snapshot_version: z.int().nullish(),
  summary: z.string().nullish(),
  version: z.int(),
  version_note: z.string().nullish(),
})

/**
 * ComposerSaveStrategy
 */
export const zComposerSaveStrategy = z.enum([
  'node_job_only',
  'save_as_new_agent',
  'save_as_new_version',
  'save_to_current_version',
  'save_to_roster',
])

/**
 * AgentComposerSoulLockResponse
 */
export const zAgentComposerSoulLockResponse = z.object({
  can_unlock: z.boolean().optional().default(false),
  locked: z.boolean(),
  reason: z.string().nullish(),
})

/**
 * ComposerBindingPayload
 */
export const zComposerBindingPayload = z.object({
  agent_id: z.string().nullish(),
  binding_type: z.enum(['inline_agent', 'roster_agent']),
  current_snapshot_id: z.string().nullish(),
})

/**
 * AgentIconType
 *
 * Supported icon storage formats for Agent roster entries.
 */
export const zAgentIconType = z.enum(['emoji', 'image', 'link'])

/**
 * ComposerSoulLockPayload
 */
export const zComposerSoulLockPayload = z.object({
  locked: z.boolean().optional().default(true),
  unlocked_from_version_id: z.string().nullish(),
})

/**
 * ComposerVariant
 */
export const zComposerVariant = z.enum(['agent_app', 'workflow'])

/**
 * ComposerCandidateCapabilities
 */
export const zComposerCandidateCapabilities = z.object({
  human_roster_available: z.boolean().optional().default(false),
})

/**
 * AgentComposerImpactBindingResponse
 */
export const zAgentComposerImpactBindingResponse = z.object({
  app_id: z.string(),
  node_id: z.string(),
  workflow_id: z.string(),
})

/**
 * AgentComposerImpactResponse
 */
export const zAgentComposerImpactResponse = z.object({
  bindings: z.array(zAgentComposerImpactBindingResponse).optional(),
  current_snapshot_id: z.string().nullish(),
  workflow_node_count: z.int(),
})

/**
 * ComposerKnowledgePlaceholderResponse
 */
export const zComposerKnowledgePlaceholderResponse = z.object({
  id: z.string(),
  placeholder_name: z.string(),
})

/**
 * ComposerValidationWarningResponse
 */
export const zComposerValidationWarningResponse = z.object({
  code: z.string(),
  id: z.string().nullish(),
  kind: z.string().nullish(),
  message: z.string().nullish(),
  surface: z.string().nullish(),
})

/**
 * AgentComposerValidateResponse
 */
export const zAgentComposerValidateResponse = z.object({
  errors: z.array(z.string()).optional(),
  knowledge_retrieval_placeholder: z.array(zComposerKnowledgePlaceholderResponse).optional(),
  result: z.literal('success'),
  warnings: z.array(zComposerValidationWarningResponse).optional(),
})

/**
 * ComposerValidationFindingsResponse
 */
export const zComposerValidationFindingsResponse = z.object({
  knowledge_retrieval_placeholder: z.array(zComposerKnowledgePlaceholderResponse).optional(),
  warnings: z.array(zComposerValidationWarningResponse).optional(),
})

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

/**
 * NodeStatus
 *
 * Coarse node-level status used by Inspector to pick a banner.
 */
export const zNodeStatus = z.enum(['failed', 'idle', 'ready', 'running'])

/**
 * NodeOutputStatus
 *
 * Lifecycle status of a single declared output within a run.
 */
export const zNodeOutputStatus = z.enum([
  'failed',
  'not_produced',
  'output_check_failed',
  'pending',
  'ready',
  'running',
  'type_check_failed',
])

/**
 * DeclaredOutputType
 */
export const zDeclaredOutputType = z.enum([
  'array',
  'boolean',
  'file',
  'number',
  'object',
  'string',
])

/**
 * OutputPreviewView
 */
export const zOutputPreviewView = z.object({
  node_id: z.string(),
  output_name: z.string(),
  status: zNodeOutputStatus,
  type: zDeclaredOutputType.nullish(),
  value: z.unknown().optional(),
})

/**
 * WorkflowDraftVariableWithoutValueResponse
 */
export const zWorkflowDraftVariableWithoutValueResponse = z.object({
  description: z.string(),
  edited: z.boolean(),
  id: z.string(),
  is_truncated: z.boolean(),
  name: z.string(),
  selector: z.array(z.string()),
  type: z.string(),
  value_type: z.string(),
  visible: z.boolean(),
})

/**
 * WorkflowDraftVariableListWithoutValueResponse
 */
export const zWorkflowDraftVariableListWithoutValueResponse = z.object({
  items: z.array(zWorkflowDraftVariableWithoutValueResponse),
  total: z.int().nullable(),
})

/**
 * WorkflowDraftVariableFullContentResponse
 */
export const zWorkflowDraftVariableFullContentResponse = z.object({
  download_url: z.string(),
  length: z.int().nullable(),
  size_bytes: z.int().nullable(),
  value_type: z.string(),
})

export const zRecursiveJsonValue = z
  .union([
    z.string(),
    z.int(),
    z.number(),
    z.boolean(),
    z.record(
      z.string(),
      z.lazy((): any => zRecursiveJsonValue),
    ),
    z.array(z.lazy((): any => zRecursiveJsonValue)),
  ])
  .nullable()

/**
 * WorkflowDraftVariableResponse
 */
export const zWorkflowDraftVariableResponse = z.object({
  description: z.string(),
  edited: z.boolean(),
  full_content: zWorkflowDraftVariableFullContentResponse.nullable(),
  id: z.string(),
  is_truncated: z.boolean(),
  name: z.string(),
  selector: z.array(z.string()),
  type: z.string(),
  value: zRecursiveJsonValue,
  value_type: z.string(),
  visible: z.boolean(),
})

/**
 * WorkflowDraftVariableListResponse
 */
export const zWorkflowDraftVariableListResponse = z.object({
  items: z.array(zWorkflowDraftVariableResponse),
})

/**
 * AppAnnotationReplyDisabledResponse
 */
export const zAppAnnotationReplyDisabledResponse = z.object({
  enabled: z.literal(false),
})

/**
 * AppEnabledExternalDataToolResponse
 */
export const zAppEnabledExternalDataToolResponse = z.object({
  config: z.record(z.string(), zJsonValue),
  enabled: z.literal(true),
  icon: z.string().optional(),
  icon_background: z.string().optional(),
  label: z.string().optional(),
  type: z.string(),
  variable: z.string(),
})

/**
 * AppDisabledExternalDataToolResponse
 */
export const zAppDisabledExternalDataToolResponse = z.object({
  config: z.record(z.string(), zJsonValue).optional(),
  enabled: z.literal(false),
  icon: z.string().optional(),
  icon_background: z.string().optional(),
  label: z.string().optional(),
  type: z.string().optional(),
  variable: z.string().optional(),
})

/**
 * AppEnabledConfigResponse
 */
export const zAppEnabledConfigResponse = z.object({
  enabled: z.boolean(),
})

/**
 * PromptType
 *
 * Prompt configuration type
 */
export const zPromptType = z.enum(['advanced', 'simple'])

/**
 * AppSensitiveWordAvoidanceResponse
 */
export const zAppSensitiveWordAvoidanceResponse = z.object({
  config: z.record(z.string(), zJsonValue).optional(),
  configs: z.array(zJsonValue).optional(),
  enabled: z.boolean(),
  type: z.string().optional(),
})

/**
 * AppTextToSpeechResponse
 */
export const zAppTextToSpeechResponse = z.object({
  autoPlay: z.enum(['disabled', 'enabled']).optional(),
  enabled: z.boolean(),
  language: z.string().optional(),
  voice: z.string().optional(),
})

/**
 * CustomizeTokenStrategy
 *
 * Site token customization strategy
 */
export const zCustomizeTokenStrategy = z.enum(['allow', 'must', 'not_allow', 'uuid'])

/**
 * AppDetailSiteResponse
 */
export const zAppDetailSiteResponse = z.object({
  access_token: z.string().nullable(),
  app_base_url: z.string(),
  chat_color_theme: z.string().nullable(),
  chat_color_theme_inverted: z.boolean(),
  code: z.string().nullable(),
  copyright: z.string().nullable(),
  created_at: z.int(),
  created_by: z.string().nullable(),
  custom_disclaimer: z.string(),
  customize_domain: z.string().nullable(),
  customize_token_strategy: zCustomizeTokenStrategy,
  default_language: z.string(),
  description: z.string().nullable(),
  icon: z.string().nullable(),
  icon_background: z.string().nullable(),
  icon_type: zIconType.nullable(),
  icon_url: z.string().nullable(),
  input_placeholder: z.string().nullable(),
  privacy_policy: z.string().nullable(),
  prompt_public: z.boolean(),
  show_workflow_steps: z.boolean(),
  title: z.string(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  use_icon_as_answer_icon: z.boolean(),
})

/**
 * PluginDependencyType
 */
export const zPluginDependencyType = z.enum(['github', 'marketplace', 'package'])

/**
 * Github
 */
export const zPluginDependencyGithub = z.object({
  github_plugin_unique_identifier: z.string(),
  package: z.string(),
  repo: z.string(),
  version: z.string(),
})

/**
 * Marketplace
 */
export const zPluginDependencyMarketplace = z.object({
  marketplace_plugin_unique_identifier: z.string(),
  version: z.string().nullish(),
})

/**
 * Package
 */
export const zPluginDependencyPackage = z.object({
  plugin_unique_identifier: z.string(),
  version: z.string().nullish(),
})

/**
 * PluginDependency
 */
export const zPluginDependency = z.object({
  current_identifier: z.string().nullish(),
  type: zPluginDependencyType,
  value: z.union([zPluginDependencyGithub, zPluginDependencyMarketplace, zPluginDependencyPackage]),
})

/**
 * CheckDependenciesResult
 */
export const zCheckDependenciesResult = z.object({
  leaked_dependencies: z.array(zPluginDependency).optional(),
})

/**
 * WorkflowOnlineUser
 */
export const zWorkflowOnlineUser = z.object({
  avatar: z.string().nullish(),
  user_id: z.string(),
  username: z.string(),
})

/**
 * WorkflowOnlineUsersByApp
 */
export const zWorkflowOnlineUsersByApp = z.object({
  app_id: z.string(),
  users: z.array(zWorkflowOnlineUser),
})

/**
 * WorkflowOnlineUsersResponse
 */
export const zWorkflowOnlineUsersResponse = z.object({
  data: z.array(zWorkflowOnlineUsersByApp),
})

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

/**
 * AgentToolCallResponse
 */
export const zAgentToolCallResponse = z.object({
  error: z.string().nullish(),
  status: z.string(),
  time_cost: z.union([z.number(), z.int()]),
  tool_icon: z.union([z.string(), z.record(z.string(), z.string())]).nullish(),
  tool_input: z.record(z.string(), z.unknown()),
  tool_label: z.union([z.string(), z.record(z.string(), z.string())]),
  tool_name: z.string(),
  tool_output: z.record(z.string(), z.unknown()),
  tool_parameters: z.record(z.string(), z.unknown()),
})

/**
 * AgentIterationLogResponse
 */
export const zAgentIterationLogResponse = z.object({
  created_at: z.string(),
  files: z.array(z.unknown()).optional(),
  thought: z.string().nullish(),
  tokens: z.int(),
  tool_calls: z.array(zAgentToolCallResponse),
  tool_raw: z.record(z.string(), z.unknown()),
})

/**
 * AgentLogResponse
 */
export const zAgentLogResponse = z.object({
  files: z.array(z.unknown()).optional(),
  iterations: z.array(zAgentIterationLogResponse),
  meta: zAgentLogMetaResponse,
})

/**
 * SimpleModelConfig
 */
export const zSimpleModelConfig = z.object({
  model: zAnyJsonValue.nullish(),
  pre_prompt: z.string().nullish(),
})

/**
 * StatusCount
 */
export const zStatusCount = z.object({
  failed: z.int(),
  partial_success: z.int(),
  paused: z.int(),
  success: z.int(),
})

/**
 * ConversationWithSummary
 */
export const zConversationWithSummary = z.object({
  admin_feedback_stats: zFeedbackStat.nullish(),
  annotated: z.boolean(),
  created_at: z.int().nullish(),
  from_account_id: z.string().nullish(),
  from_account_name: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_end_user_session_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  message_count: z.int(),
  model_config: zSimpleModelConfig.nullish(),
  name: z.string(),
  read_at: z.int().nullish(),
  status: z.string(),
  status_count: zStatusCount.nullish(),
  summary: z.string(),
  updated_at: z.int().nullish(),
  user_feedback_stats: zFeedbackStat.nullish(),
})

/**
 * ConversationWithSummaryPagination
 */
export const zConversationWithSummaryPagination = z.object({
  data: z.array(zConversationWithSummary),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * SimpleMessageDetail
 */
export const zSimpleMessageDetail = z.object({
  answer: z.string(),
  inputs: z.record(z.string(), zAnyJsonValue),
  message: z.string(),
  query: z.string(),
})

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

/**
 * ConversationAnnotation
 */
export const zConversationAnnotation = z.object({
  account: zSimpleAccount.nullish(),
  content: z.string(),
  created_at: z.int().nullish(),
  id: z.string(),
  question: z.string().nullish(),
})

/**
 * Conversation
 */
export const zConversation = z.object({
  admin_feedback_stats: zFeedbackStat.nullish(),
  annotation: zConversationAnnotation.nullish(),
  created_at: z.int().nullish(),
  from_account_id: z.string().nullish(),
  from_account_name: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_end_user_session_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  message: zSimpleMessageDetail.nullish(),
  model_config: zSimpleModelConfig.nullish(),
  read_at: z.int().nullish(),
  status: z.string(),
  updated_at: z.int().nullish(),
  user_feedback_stats: zFeedbackStat.nullish(),
})

/**
 * ConversationPagination
 */
export const zConversationPagination = z.object({
  data: z.array(zConversation),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * ConversationAnnotationHitHistory
 */
export const zConversationAnnotationHitHistory = z.object({
  annotation_create_account: zSimpleAccount.nullish(),
  annotation_id: z.string(),
  created_at: z.int().nullish(),
})

/**
 * Feedback
 */
export const zFeedback = z.object({
  content: z.string().nullish(),
  from_account: zSimpleAccount.nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  rating: z.string(),
})

/**
 * 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(), zJsonValue).nullish(),
})

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

/**
 * KnowledgeFsCitation
 *
 * Immutable evidence identity; no signed URLs, tokens or storage keys.
 */
export const zKnowledgeFsCitation = z.object({
  artifact_hash: z.string().min(1).max(255),
  control_space_id: z.string().length(36),
  document_asset_id: z.string().min(1).max(512),
  document_title: z.string().max(2000).nullish(),
  document_version: z.int().gte(1).nullish(),
  end_offset: z.int().gte(0).nullish(),
  id: z.string().regex(/^kfs_[a-f0-9]{32}$/),
  node_id: z.string().min(1).max(512),
  page_number: z.int().gte(0).nullish(),
  parse_artifact_id: z.string().max(512).nullish(),
  section_path: z.array(z.string()).max(64).optional(),
  space_name: z.string().min(1).max(120),
  start_offset: z.int().gte(0).nullish(),
})

/**
 * RetrievalSourceMetadata
 */
export const zRetrievalSourceMetadata = z.object({
  content: z.string().nullish(),
  data_source_type: z.string().nullish(),
  dataset_id: z.string().nullish(),
  dataset_name: z.string().nullish(),
  doc_metadata: z.record(z.string(), z.unknown()).nullish(),
  document_asset_id: z.string().nullish(),
  document_id: z.string().nullish(),
  document_name: z.string().nullish(),
  document_revision: z.int().nullish(),
  document_version: z.int().nullish(),
  files: z.array(z.record(z.string(), z.unknown())).nullish(),
  hit_count: z.int().nullish(),
  index_node_hash: z.string().nullish(),
  knowledge_fs_citation: zKnowledgeFsCitation.nullish(),
  page: z.int().nullish(),
  position: z.int().nullish(),
  retriever_from: z.string().nullish(),
  score: z.number().nullish(),
  segment_id: z.string().nullish(),
  segment_position: z.int().nullish(),
  summary: z.string().nullish(),
  title: z.string().nullish(),
  word_count: z.int().nullish(),
})

/**
 * MessageDetail
 */
export const zMessageDetail = z.object({
  agent_thoughts: z.array(zAgentThought),
  annotation: zConversationAnnotation.nullish(),
  annotation_hit_history: zConversationAnnotationHitHistory.nullish(),
  answer: z.string(),
  answer_tokens: z.int(),
  conversation_id: z.string(),
  created_at: z.int().nullish(),
  error: z.string().nullish(),
  feedbacks: z.array(zFeedback),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  inputs: z.record(z.string(), zAnyJsonValue),
  message: zAnyJsonValue,
  message_files: z.array(zMessageFile),
  message_tokens: z.int(),
  metadata: zAnyJsonValue,
  parent_message_id: z.string().nullish(),
  provider_response_latency: z.number(),
  query: z.string(),
  retriever_resources: z.array(zRetrievalSourceMetadata).optional(),
  status: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * ConversationMessageDetail
 */
export const zConversationMessageDetail = z.object({
  created_at: z.int().nullish(),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  message: zMessageDetail.nullish(),
  model_config: zConversationModelConfig.nullish(),
  status: z.string(),
})

export const zAppConfigJsonValue = z.json().nullable()

/**
 * AppExternalDataToolPayload
 */
export const zAppExternalDataToolPayload = z
  .object({
    config: z.record(z.string(), zAppConfigJsonValue).optional(),
    enabled: z.boolean().nullish(),
    icon: z.string().optional(),
    icon_background: z.string().optional(),
    label: z.string().optional(),
    type: z.string().optional(),
    variable: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppModelSelectionPayload
 */
export const zAppModelSelectionPayload = z
  .object({
    completion_params: z.record(z.string(), zAppConfigJsonValue),
    mode: z.string().nullish(),
    name: z.string(),
    provider: z.string(),
  })
  .catchall(z.json())

/**
 * AppFeaturePayload
 */
export const zAppFeaturePayload = z
  .object({
    enabled: z.boolean().nullish(),
  })
  .catchall(z.json())

/**
 * AppTextToSpeechPayload
 */
export const zAppTextToSpeechPayload = z
  .object({
    autoPlay: z.enum(['disabled', 'enabled']).optional(),
    enabled: z.boolean().nullish(),
    language: z.string().optional(),
    voice: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppAgentPromptPayload
 */
export const zAppAgentPromptPayload = z
  .object({
    first_prompt: z.string().optional(),
    next_iteration: z.string().optional(),
  })
  .catchall(z.json())

/**
 * PlanningStrategy
 */
export const zPlanningStrategy = z.enum(['function_call', 'react', 'react_router', 'router'])

/**
 * AppPromptMessagePayload
 */
export const zAppPromptMessagePayload = z
  .object({
    role: z.string(),
    text: z.string(),
  })
  .catchall(z.json())

/**
 * AppChatPromptPayload
 */
export const zAppChatPromptPayload = z
  .object({
    prompt: z.array(zAppPromptMessagePayload).optional(),
  })
  .catchall(z.json())

/**
 * AppConversationRolesPayload
 */
export const zAppConversationRolesPayload = z
  .object({
    assistant_prefix: z.string(),
    user_prefix: z.string(),
  })
  .catchall(z.json())

/**
 * AppCompletionPromptTextPayload
 */
export const zAppCompletionPromptTextPayload = z
  .object({
    text: z.string(),
  })
  .catchall(z.json())

/**
 * AppCompletionPromptPayload
 */
export const zAppCompletionPromptPayload = z
  .object({
    conversation_histories_role: zAppConversationRolesPayload.optional(),
    prompt: zAppCompletionPromptTextPayload.optional(),
  })
  .catchall(z.json())

/**
 * AppEmptyDatasetCollectionPayload
 */
export const zAppEmptyDatasetCollectionPayload = z.record(z.string(), z.never())

/**
 * RerankMode
 */
export const zRerankMode = z.enum(['reranking_model', 'weighted_score'])

/**
 * AppRerankingModelPayload
 */
export const zAppRerankingModelPayload = z
  .object({
    reranking_model_name: z.string().optional(),
    reranking_provider_name: z.string().optional(),
  })
  .catchall(z.json())

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

/**
 * AppFileTypeUploadPayload
 */
export const zAppFileTypeUploadPayload = z
  .object({
    enabled: z.boolean().nullish(),
    number_limits: z.int().nullish(),
    transfer_methods: z.array(zFileTransferMethod).nullish(),
  })
  .catchall(z.json())

/**
 * AppImageUploadPayload
 */
export const zAppImageUploadPayload = z
  .object({
    detail: z.enum(['high', 'low']).nullish(),
    enabled: z.boolean().optional(),
    number_limits: z.int().optional(),
    transfer_methods: z.array(zFileTransferMethod).optional(),
  })
  .catchall(z.json())

/**
 * AppImageConfigPayload
 */
export const zAppImageConfigPayload = z
  .object({
    detail: z.enum(['high', 'low']).nullish(),
    number_limits: z.int().optional(),
    transfer_methods: z.array(zFileTransferMethod).optional(),
  })
  .catchall(z.json())

/**
 * AppFilePreviewPayload
 */
export const zAppFilePreviewPayload = z
  .object({
    file_type_list: z.array(z.string()).nullish(),
    mode: z.string().nullish(),
  })
  .catchall(z.json())

/**
 * AppFileUploadPayload
 */
export const zAppFileUploadPayload = 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(),
    audio: zAppFileTypeUploadPayload.nullish(),
    custom: zAppFileTypeUploadPayload.nullish(),
    document: zAppFileTypeUploadPayload.nullish(),
    enabled: z.boolean().optional(),
    image: zAppImageUploadPayload.optional(),
    image_config: zAppImageConfigPayload.nullish(),
    number_limits: z.int().optional(),
    preview_config: zAppFilePreviewPayload.nullish(),
    video: zAppFileTypeUploadPayload.nullish(),
  })
  .catchall(z.json())

/**
 * WorkflowRunForLogResponse
 */
export const zWorkflowRunForLogResponse = z.object({
  created_at: z.int().nullish(),
  elapsed_time: z.number().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: zSimpleAccountResponse.nullish(),
  created_by_end_user: zSimpleEndUser.nullish(),
  created_by_role: z.string().nullish(),
  created_from: z.string().nullish(),
  details: z.unknown().optional(),
  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(),
})

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

/**
 * AccountWithRoleResponse
 */
export const zAccountWithRoleResponse = z.object({
  avatar: z.string().nullish(),
  avatar_url: z.string().nullable(),
  created_at: z.int().nullish(),
  email: z.string(),
  id: z.string(),
  last_active_at: z.int().nullish(),
  last_login_at: z.int().nullish(),
  name: z.string(),
  role: z.string(),
  roles: z.array(zMemberRoleSummaryResponse).optional(),
  status: z.string(),
})

/**
 * WorkflowCommentMentionUsersPayload
 */
export const zWorkflowCommentMentionUsersPayload = z.object({
  users: z.array(zAccountWithRoleResponse),
})

/**
 * WorkflowFeatureTogglePayload
 */
export const zWorkflowFeatureTogglePayload = z.object({
  enabled: z.boolean().nullish(),
})

/**
 * WorkflowSensitiveWordAvoidancePayload
 */
export const zWorkflowSensitiveWordAvoidancePayload = z.object({
  config: z.record(z.string(), z.unknown()).nullish(),
  enabled: z.boolean().nullish(),
  type: z.string().nullish(),
})

/**
 * WorkflowSuggestedQuestionsAfterAnswerPayload
 */
export const zWorkflowSuggestedQuestionsAfterAnswerPayload = z.object({
  enabled: z.boolean().nullish(),
  model: z.record(z.string(), z.unknown()).nullish(),
  prompt: z.string().nullish(),
})

/**
 * WorkflowTextToSpeechPayload
 */
export const zWorkflowTextToSpeechPayload = z.object({
  autoPlay: z.enum(['disabled', 'enabled']).nullish(),
  enabled: z.boolean().nullish(),
  language: z.string().nullish(),
  voice: z.string().nullish(),
})

/**
 * AgentScope
 *
 * Visibility and lifecycle scope of an Agent record.
 */
export const zAgentScope = z.enum(['roster', 'workflow_only'])

/**
 * AgentSource
 *
 * Origin that created or imported the Agent.
 */
export const zAgentSource = z.enum(['agent_app', 'imported', 'roster', 'system', 'workflow'])

/**
 * AgentStatus
 *
 * Soft lifecycle state for Agent records.
 */
export const zAgentStatus = z.enum(['active', 'archived'])

/**
 * AgentComposerAgentResponse
 */
export const zAgentComposerAgentResponse = z.object({
  active_config_snapshot_id: z.string().nullish(),
  app_id: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  description: z.string(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  id: z.string(),
  name: z.string(),
  role: z.string().nullish(),
  scope: zAgentScope,
  source: zAgentSource.nullish(),
  status: zAgentStatus,
})

/**
 * AppVariableConfig
 */
export const zAppVariableConfig = z.object({
  default: z.unknown().optional(),
  name: z.string().min(1).max(255),
  required: z.boolean().optional().default(false),
  type: z.string().min(1).max(64),
})

/**
 * AgentConfigFileRefConfig
 *
 * Stable Agent Soul reference to one config file payload.
 */
export const zAgentConfigFileRefConfig = z.object({
  file_id: z.string().max(255).optional().default(''),
  file_kind: z.enum(['tool_file', 'upload_file']),
  hash: z.string().nullish(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish(),
  name: z.string().min(1).max(255),
  size: z.int().nullish(),
})

/**
 * AgentConfigSkillRefConfig
 *
 * Stable Agent Soul reference to one normalized skill archive.
 */
export const zAgentConfigSkillRefConfig = z.object({
  description: z.string().optional().default(''),
  file_id: z.string().max(255).optional().default(''),
  file_kind: z.literal('tool_file').optional().default('tool_file'),
  hash: z.string().nullish(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish().default('application/zip'),
  name: z.string().min(1).max(255),
  size: z.int().nullish(),
})

/**
 * AgentSoulPromptConfig
 */
export const zAgentSoulPromptConfig = z.object({
  system_prompt: z.string().optional().default(''),
})

/**
 * WorkflowAgentBindingType
 *
 * How a workflow node is bound to an Agent.
 */
export const zWorkflowAgentBindingType = z.enum(['inline_agent', 'roster_agent'])

/**
 * AgentComposerBindingResponse
 */
export const zAgentComposerBindingResponse = z.object({
  agent_id: z.string().nullish(),
  binding_type: zWorkflowAgentBindingType,
  current_snapshot_id: z.string().nullish(),
  id: z.string(),
  node_id: z.string(),
  workflow_id: z.string(),
})

/**
 * DeclaredArrayItem
 *
 * Per-item shape for an ``array``-typed declared output.
 *
 * The PRD output configuration section limits arrays to one level; nested arrays
 * are rejected so the runtime type checker and JSON Schema stay easy to reason
 * about. Stage 4 §4.2.
 */
export const zDeclaredArrayItem = z.object({
  children: z
    .array(
      z.object({
        array_item: z
          .object({
            children: z.array(z.record(z.string(), z.unknown())).optional(),
            description: z.string().nullish(),
            type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']).optional(),
          })
          .nullish(),
        children: z.array(z.record(z.string(), z.unknown())).optional(),
        description: z.string().nullish(),
        file: z.record(z.string(), z.unknown()).nullish(),
        name: z.string(),
        required: z.boolean().optional(),
        type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']),
      }),
    )
    .optional(),
  description: z.string().nullish(),
  type: zDeclaredOutputType,
})

/**
 * DeclaredOutputFileConfig
 *
 * File-type output metadata. Both lists empty means "any file accepted".
 */
export const zDeclaredOutputFileConfig = z.object({
  extensions: z.array(z.string()).optional(),
  mime_types: z.array(z.string()).optional(),
})

/**
 * AgentHumanContactConfig
 */
export const zAgentHumanContactConfig = z.object({
  channel: z.string().max(64).nullish(),
  contact_id: z.string().max(255).nullish(),
  contact_method: z.string().max(64).nullish(),
  email: z.string().max(255).nullish(),
  human_id: z.string().max(255).nullish(),
  id: z.string().max(255).nullish(),
  method: z.string().max(64).nullish(),
  name: z.string().max(255).nullish(),
  tenant_id: z.string().max(255).nullish(),
})

/**
 * WorkflowNodeJobMode
 */
export const zWorkflowNodeJobMode = z.enum(['let_agent_figure_it_out', 'tell_agent_what_to_do'])

/**
 * WorkflowPreviousNodeOutputRef
 */
export const zWorkflowPreviousNodeOutputRef = z.object({
  key: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  node_id: z.string().max(255).nullish(),
  output: z.string().max(255).nullish(),
  selector: z.array(z.union([z.string(), z.int(), z.number(), z.boolean(), z.null()])).nullish(),
  value_selector: z
    .array(z.union([z.string(), z.int(), z.number(), z.boolean(), z.null()]))
    .nullish(),
  variable: z.string().max(255).nullish(),
  variable_selector: z
    .array(z.union([z.string(), z.int(), z.number(), z.boolean(), z.null()]))
    .nullish(),
})

/**
 * AgentComposerNodeJobCandidatesResponse
 */
export const zAgentComposerNodeJobCandidatesResponse = z.object({
  declare_output_types: z.array(zDeclaredOutputType).optional(),
  human_contacts: z.array(zAgentHumanContactConfig).optional(),
  previous_node_outputs: z.array(zWorkflowPreviousNodeOutputRef).optional(),
})

/**
 * AgentComposerDifyToolCandidateResponse
 */
export const zAgentComposerDifyToolCandidateResponse = z.object({
  description: z.string().nullish(),
  granularity: z.string().nullish(),
  id: z.string().nullish(),
  name: z.string().nullish(),
  plugin_id: z.string().nullish(),
  provider: z.string().nullish(),
  provider_id: z.string().nullish(),
  tools_count: z.int().nullish(),
})

/**
 * CheckResultView
 *
 * ``type_check`` / ``output_check`` per-output summary block.
 */
export const zCheckResultView = z.object({
  passed: z.boolean(),
  reason: z.string().nullish(),
})

/**
 * NodeOutputView
 */
export const zNodeOutputView = z.object({
  name: z.string(),
  output_check: zCheckResultView.nullish(),
  retried: z.int().optional().default(0),
  status: zNodeOutputStatus,
  type: zDeclaredOutputType.nullish(),
  type_check: zCheckResultView.nullish(),
  value_preview: z.unknown().optional(),
})

/**
 * NodeOutputsView
 */
export const zNodeOutputsView = z.object({
  node_completed_at: z.iso.datetime().nullish(),
  node_display_name: z.string(),
  node_id: z.string(),
  node_kind: z.string(),
  node_started_at: z.iso.datetime().nullish(),
  node_status: zNodeStatus,
  outputs: z.array(zNodeOutputView).optional(),
})

/**
 * WorkflowRunSnapshotView
 */
export const zWorkflowRunSnapshotView = z.object({
  node_outputs: z.array(zNodeOutputsView).optional(),
  workflow_run_id: z.string(),
  workflow_run_status: zWorkflowExecutionStatus,
})

/**
 * AppAgentPromptResponse
 */
export const zAppAgentPromptResponse = z.object({
  first_prompt: z.string().optional(),
  next_iteration: z.string().optional(),
})

/**
 * AppLegacyGoogleSearchToolResponse
 */
export const zAppLegacyGoogleSearchToolResponse = z.object({
  google_search: z.record(z.string(), zJsonValue),
})

/**
 * AppLegacyWebReaderToolResponse
 */
export const zAppLegacyWebReaderToolResponse = z.object({
  web_reader: z.record(z.string(), zJsonValue),
})

/**
 * AppLegacyWikipediaToolResponse
 */
export const zAppLegacyWikipediaToolResponse = z.object({
  wikipedia: z.record(z.string(), zJsonValue),
})

/**
 * AppLegacyCurrentDatetimeToolResponse
 */
export const zAppLegacyCurrentDatetimeToolResponse = z.object({
  current_datetime: z.record(z.string(), zJsonValue),
})

/**
 * AppEmbeddingModelResponse
 */
export const zAppEmbeddingModelResponse = z.object({
  embedding_model_name: z.string(),
  embedding_provider_name: z.string(),
})

/**
 * AppAnnotationReplyEnabledResponse
 */
export const zAppAnnotationReplyEnabledResponse = z.object({
  embedding_model: zAppEmbeddingModelResponse,
  enabled: z.literal(true),
  id: z.string(),
  score_threshold: z.number(),
})

/**
 * AppChatPromptMessageResponse
 */
export const zAppChatPromptMessageResponse = z.object({
  role: z.string(),
  text: z.string(),
})

/**
 * AppChatPromptConfigResponse
 */
export const zAppChatPromptConfigResponse = z.object({
  prompt: z.array(zAppChatPromptMessageResponse).optional(),
})

/**
 * AppConversationHistoriesRoleResponse
 */
export const zAppConversationHistoriesRoleResponse = z.object({
  assistant_prefix: z.string(),
  user_prefix: z.string(),
})

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

/**
 * AppCompletionPromptConfigResponse
 */
export const zAppCompletionPromptConfigResponse = z.object({
  conversation_histories_role: zAppConversationHistoriesRoleResponse.optional(),
  prompt: zAppCompletionPromptTextResponse.optional(),
})

/**
 * AppRerankingModelResponse
 */
export const zAppRerankingModelResponse = z.object({
  reranking_model_name: z.string().optional(),
  reranking_provider_name: z.string().optional(),
})

/**
 * AppImageUploadResponse
 */
export const zAppImageUploadResponse = z.object({
  detail: z.enum(['high', 'low']).nullish(),
  enabled: z.boolean().optional(),
  number_limits: z.int().optional(),
  transfer_methods: z.array(zFileTransferMethod).optional(),
})

/**
 * AppFileUploadResponse
 */
export const zAppFileUploadResponse = 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(),
  enabled: z.boolean().optional(),
  image: zAppImageUploadResponse.optional(),
  number_limits: z.int().optional(),
})

/**
 * LLMMode
 *
 * Enum class for large language model mode.
 */
export const zLlmMode = z.enum(['chat', 'completion'])

/**
 * AppModelSelectionResponse
 */
export const zAppModelSelectionResponse = z.object({
  completion_params: z.record(z.string(), zJsonValue).optional(),
  mode: z.union([zLlmMode, z.literal('')]).optional(),
  name: z.string().optional(),
  provider: z.string().optional(),
})

/**
 * ModelConfigPartial
 */
export const zModelConfigPartial = z.object({
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  model: zAppModelSelectionResponse.nullish(),
  pre_prompt: z.string().nullish(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
})

/**
 * AppPartial
 */
export const zAppPartial = z.object({
  access_mode: zWebAppAccessMode.nullish(),
  app_id: z.string().nullish(),
  author_name: z.string().nullish(),
  bound_agent_id: z.string().nullish(),
  create_user_name: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  description: z.string().nullish(),
  has_draft_trigger: z.boolean().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  icon_url: z.string().nullable(),
  id: z.string(),
  is_starred: z.boolean().optional().default(false),
  maintainer: z.string().nullish(),
  max_active_requests: z.int().nullish(),
  mode: zAppMode,
  model_config: zModelConfigPartial.nullish(),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  tags: z.array(zTag).optional(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
  workflow: zWorkflowPartial.nullish(),
})

/**
 * AppPagination
 */
export const zAppPagination = z.object({
  data: z.array(zAppPartial),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * AppSuggestedQuestionsAfterAnswerResponse
 */
export const zAppSuggestedQuestionsAfterAnswerResponse = z.object({
  enabled: z.boolean(),
  model: zAppModelSelectionResponse.optional(),
  prompt: z.string().optional(),
})

/**
 * AppMetadataModelPayload
 */
export const zAppMetadataModelPayload = z
  .object({
    completion_params: z.record(z.string(), zAppConfigJsonValue).optional(),
    mode: z.union([zLlmMode, z.literal('')]).optional(),
    name: z.string().optional(),
    provider: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppSuggestedQuestionsModelPayload
 */
export const zAppSuggestedQuestionsModelPayload = z
  .object({
    completion_params: z.record(z.string(), zAppConfigJsonValue).optional(),
    mode: z.union([zLlmMode, z.literal('')]).optional(),
    name: z.string(),
    provider: z.string(),
  })
  .catchall(z.json())

/**
 * AppSuggestedQuestionsPayload
 */
export const zAppSuggestedQuestionsPayload = z
  .object({
    enabled: z.boolean().nullish(),
    model: zAppSuggestedQuestionsModelPayload.optional(),
    prompt: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppUserInputFormConfigResponse
 */
export const zAppUserInputFormConfigResponse = 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(),
  config: z.record(z.string(), zJsonValue).optional(),
  default: zJsonValue.optional(),
  description: z.string().optional(),
  enabled: z.boolean().optional(),
  hide: z.boolean().optional(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  json_schema: z.union([z.string(), z.record(z.string(), zJsonValue)]).nullish(),
  label: z.string(),
  max_length: z.int().nullish(),
  options: z.array(z.string()).optional(),
  required: z.boolean().optional(),
  type: z.string().optional(),
  variable: z.string(),
})

/**
 * AppTextInputFormResponse
 */
export const zAppTextInputFormResponse = z.object({
  'text-input': zAppUserInputFormConfigResponse,
})

/**
 * AppSelectFormResponse
 */
export const zAppSelectFormResponse = z.object({
  select: zAppUserInputFormConfigResponse,
})

/**
 * AppParagraphFormResponse
 */
export const zAppParagraphFormResponse = z.object({
  paragraph: zAppUserInputFormConfigResponse,
})

/**
 * AppNumberFormResponse
 */
export const zAppNumberFormResponse = z.object({
  number: zAppUserInputFormConfigResponse,
})

/**
 * AppCheckboxFormResponse
 */
export const zAppCheckboxFormResponse = z.object({
  checkbox: zAppUserInputFormConfigResponse,
})

/**
 * AppFileFormResponse
 */
export const zAppFileFormResponse = z.object({
  file: zAppUserInputFormConfigResponse,
})

/**
 * AppFileListFormResponse
 */
export const zAppFileListFormResponse = z.object({
  'file-list': zAppUserInputFormConfigResponse,
})

/**
 * AppExternalDataToolFormResponse
 */
export const zAppExternalDataToolFormResponse = z.object({
  external_data_tool: zAppUserInputFormConfigResponse,
})

/**
 * AppJsonObjectFormResponse
 */
export const zAppJsonObjectFormResponse = z.object({
  json_object: zAppUserInputFormConfigResponse,
})

/**
 * AppLegacyGoogleSearchToolPayload
 */
export const zAppLegacyGoogleSearchToolPayload = z
  .object({
    google_search: zAppFeaturePayload,
  })
  .catchall(z.json())

/**
 * AppLegacyWebReaderToolPayload
 */
export const zAppLegacyWebReaderToolPayload = z
  .object({
    web_reader: zAppFeaturePayload,
  })
  .catchall(z.json())

/**
 * AppLegacyWikipediaToolPayload
 */
export const zAppLegacyWikipediaToolPayload = z
  .object({
    wikipedia: zAppFeaturePayload,
  })
  .catchall(z.json())

/**
 * AppLegacyCurrentDatetimeToolPayload
 */
export const zAppLegacyCurrentDatetimeToolPayload = z
  .object({
    current_datetime: zAppFeaturePayload,
  })
  .catchall(z.json())

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

/**
 * AppMetadataFilteringPayload
 */
export const zAppMetadataFilteringPayload = z
  .object({
    conditions: z.array(zAppMetadataConditionPayload).nullish(),
    logical_operator: z.enum(['and', 'or']).nullish(),
  })
  .catchall(z.json())

/**
 * AppKeywordWeightPayload
 */
export const zAppKeywordWeightPayload = z
  .object({
    keyword_weight: z.number(),
  })
  .catchall(z.json())

/**
 * AppVectorWeightPayload
 */
export const zAppVectorWeightPayload = z
  .object({
    embedding_model_name: z.string(),
    embedding_provider_name: z.string(),
    vector_weight: z.number(),
  })
  .catchall(z.json())

/**
 * AppRetrievalWeightsPayload
 */
export const zAppRetrievalWeightsPayload = z
  .object({
    keyword_setting: zAppKeywordWeightPayload,
    vector_setting: zAppVectorWeightPayload,
    weight_type: z.enum(['customized', 'keyword_first', 'semantic_first']).optional(),
  })
  .catchall(z.json())

/**
 * AppModerationContentPayload
 */
export const zAppModerationContentPayload = z
  .object({
    enabled: z.boolean().nullish(),
    preset_response: z.string().nullish(),
  })
  .catchall(z.json())

/**
 * AppModerationConfigPayload
 */
export const zAppModerationConfigPayload = z
  .object({
    api_based_extension_id: z.string().nullish(),
    inputs_config: zAppModerationContentPayload.nullish(),
    keywords: z.string().nullish(),
    outputs_config: zAppModerationContentPayload.nullish(),
  })
  .catchall(z.json())

/**
 * AppModerationPayload
 */
export const zAppModerationPayload = z.object({
  config: zAppModerationConfigPayload.nullish(),
  enabled: z.boolean().nullish(),
  type: z.string().nullish(),
})

/**
 * AppInputFieldPayload
 */
export const zAppInputFieldPayload = z
  .object({
    config: z.record(z.string(), zAppConfigJsonValue).optional(),
    default: zAppConfigJsonValue.optional(),
    description: z.string().optional(),
    enabled: z.boolean().optional(),
    hide: z.boolean().optional(),
    icon: z.string().nullish(),
    icon_background: z.string().nullish(),
    json_schema: z.union([z.string(), z.record(z.string(), zAppConfigJsonValue)]).nullish(),
    label: z.string(),
    max_length: z.int().nullish(),
    options: z.array(z.string()).optional(),
    required: z.boolean().nullish(),
    type: z.string().optional(),
    variable: z.string(),
  })
  .catchall(z.json())

/**
 * AppTextInputPayload
 */
export const zAppTextInputPayload = z
  .object({
    'text-input': zAppInputFieldPayload,
  })
  .strict()

/**
 * AppParagraphInputPayload
 */
export const zAppParagraphInputPayload = z
  .object({
    paragraph: zAppInputFieldPayload,
  })
  .strict()

/**
 * AppNumberInputPayload
 */
export const zAppNumberInputPayload = z
  .object({
    number: zAppInputFieldPayload,
  })
  .strict()

/**
 * AppCheckboxInputPayload
 */
export const zAppCheckboxInputPayload = z
  .object({
    checkbox: zAppInputFieldPayload,
  })
  .strict()

/**
 * AppExternalDataInputPayload
 */
export const zAppExternalDataInputPayload = z
  .object({
    external_data_tool: zAppInputFieldPayload,
  })
  .strict()

/**
 * AppSelectFieldPayload
 */
export const zAppSelectFieldPayload = z
  .object({
    config: z.record(z.string(), zAppConfigJsonValue).optional(),
    default: zAppConfigJsonValue.optional(),
    description: z.string().optional(),
    enabled: z.boolean().optional(),
    hide: z.boolean().optional(),
    icon: z.string().nullish(),
    icon_background: z.string().nullish(),
    json_schema: z.union([z.string(), z.record(z.string(), zAppConfigJsonValue)]).nullish(),
    label: z.string(),
    max_length: z.int().nullish(),
    options: z.array(z.string()).nullish(),
    required: z.boolean().nullish(),
    type: z.string().optional(),
    variable: z.string(),
  })
  .catchall(z.json())

/**
 * AppSelectInputPayload
 */
export const zAppSelectInputPayload = z
  .object({
    select: zAppSelectFieldPayload,
  })
  .strict()

export const zAppUserInputFormPayload = z.union([
  zAppTextInputPayload,
  zAppSelectInputPayload,
  zAppParagraphInputPayload,
  zAppNumberInputPayload,
  zAppCheckboxInputPayload,
  zAppExternalDataInputPayload,
])

/**
 * WorkflowFileUploadTransferPayload
 */
export const zWorkflowFileUploadTransferPayload = z.object({
  enabled: z.boolean().nullish(),
  number_limits: z.int().nullish(),
  transfer_methods: z.array(z.string()).nullish(),
})

/**
 * WorkflowFileUploadImagePayload
 */
export const zWorkflowFileUploadImagePayload = z.object({
  detail: z.string().nullish(),
  enabled: z.boolean().nullish(),
  number_limits: z.int().nullish(),
  transfer_methods: z.array(z.string()).nullish(),
})

/**
 * WorkflowFileUploadPreviewConfigPayload
 */
export const zWorkflowFileUploadPreviewConfigPayload = z.object({
  file_type_list: z.array(z.string()).nullish(),
  mode: z.string().nullish(),
})

/**
 * WorkflowFileUploadPayload
 */
export const zWorkflowFileUploadPayload = z.object({
  allowed_file_extensions: z.array(z.string()).nullish(),
  allowed_file_types: z.array(z.string()).nullish(),
  allowed_file_upload_methods: z.array(z.string()).nullish(),
  audio: zWorkflowFileUploadTransferPayload.nullish(),
  custom: zWorkflowFileUploadTransferPayload.nullish(),
  document: zWorkflowFileUploadTransferPayload.nullish(),
  enabled: z.boolean().nullish(),
  fileUploadConfig: z.record(z.string(), z.unknown()).nullish(),
  image: zWorkflowFileUploadImagePayload.nullish(),
  number_limits: z.int().nullish(),
  preview_config: zWorkflowFileUploadPreviewConfigPayload.nullish(),
  video: zWorkflowFileUploadTransferPayload.nullish(),
})

/**
 * WorkflowFeaturesConfigPayload
 */
export const zWorkflowFeaturesConfigPayload = z.object({
  file_upload: zWorkflowFileUploadPayload.nullish(),
  opening_statement: z.string().nullish(),
  retriever_resource: zWorkflowFeatureTogglePayload.nullish(),
  sensitive_word_avoidance: zWorkflowSensitiveWordAvoidancePayload.nullish(),
  speech_to_text: zWorkflowFeatureTogglePayload.nullish(),
  suggested_questions: z.array(z.string()).nullish(),
  suggested_questions_after_answer: zWorkflowSuggestedQuestionsAfterAnswerPayload.nullish(),
  text_to_speech: zWorkflowTextToSpeechPayload.nullish(),
})

/**
 * WorkflowFeaturesPayload
 */
export const zWorkflowFeaturesPayload = z.object({
  features: zWorkflowFeaturesConfigPayload,
})

/**
 * AgentFeatureToggleConfig
 */
export const zAgentFeatureToggleConfig = z.object({
  enabled: z.boolean().optional().default(false),
})

/**
 * AgentTextToSpeechFeatureConfig
 */
export const zAgentTextToSpeechFeatureConfig = z.object({
  autoPlay: z.enum(['disabled', 'enabled']).nullish(),
  enabled: z.boolean().optional().default(false),
  language: z.string().nullish(),
  voice: z.string().nullish(),
})

/**
 * AgentEnvVariableConfig
 */
export const zAgentEnvVariableConfig = z.object({
  default: z
    .union([
      z.string(),
      z.int(),
      z.number(),
      z.boolean(),
      z.array(z.string()),
      z.array(z.int()),
      z.array(z.number()),
      z.array(z.boolean()),
    ])
    .nullish(),
  env_name: z.string().max(255).nullish(),
  key: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  required: z.boolean().optional().default(false),
  type: z.string().max(64).nullish(),
  value: z
    .union([
      z.string(),
      z.int(),
      z.number(),
      z.boolean(),
      z.array(z.string()),
      z.array(z.int()),
      z.array(z.number()),
      z.array(z.boolean()),
    ])
    .nullish(),
  variable: z.string().max(255).nullish(),
})

/**
 * AgentHumanToolConfig
 */
export const zAgentHumanToolConfig = z.object({
  description: z.string().nullish(),
  enabled: z.boolean().optional().default(true),
  name: z.string().max(255).nullish(),
})

/**
 * AgentSoulHumanConfig
 */
export const zAgentSoulHumanConfig = z.object({
  contacts: z.array(zAgentHumanContactConfig).optional(),
  tools: z.array(zAgentHumanToolConfig).optional(),
})

/**
 * AgentKnowledgeSpaceConfig
 *
 * One read-only Agent Knowledge Base binding, addressed by stable ID or CLI alias.
 *
 * The control-space ID is Dify-owned, never the execution-plane space ID.
 * ``is_missing`` preserves unresolved DSL references for editing; it never
 * authorizes execution. Names/descriptions are author guidance, not authority.
 */
export const zAgentKnowledgeSpaceConfig = z.object({
  control_space_id: z.string().length(36),
  description: z.string().max(2000).nullish(),
  id: z.string().min(1).max(255),
  is_missing: z.boolean().optional().default(false),
  name: z.string().min(1).max(120),
})

/**
 * AgentMemoryArtifactConfig
 */
export const zAgentMemoryArtifactConfig = z.object({
  id: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  type: z.string().max(64).nullish(),
  url: z.string().nullish(),
})

/**
 * AgentSoulMemoryConfig
 */
export const zAgentSoulMemoryConfig = z.object({
  artifacts: z.array(zAgentMemoryArtifactConfig).optional(),
  budget: z.string().nullish(),
  scope: z.string().nullish(),
})

/**
 * AgentSoulModelCredentialRef
 *
 * Reference to model credentials resolved only at runtime.
 */
export const zAgentSoulModelCredentialRef = z.object({
  id: z.string().max(255).nullish(),
  provider: z.string().max(255).nullish(),
  type: z.string().min(1).max(64),
})

/**
 * AgentSandboxProviderConfig
 */
export const zAgentSandboxProviderConfig = z.object({
  cpu: z.int().gte(1).nullish(),
  env: z.array(zAgentEnvVariableConfig).optional(),
  image: z.string().nullish(),
  working_dir: z.string().nullish(),
})

/**
 * AgentSoulSandboxConfig
 */
export const zAgentSoulSandboxConfig = z.object({
  config: zAgentSandboxProviderConfig.optional(),
  provider: z.string().nullish(),
})

/**
 * AgentFileRefConfig
 */
export const zAgentFileRefConfig = z.object({
  file_id: z.string().max(255).nullish(),
  id: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  reference: z.string().max(255).nullish(),
  remote_url: z.string().nullish(),
  tenant_id: z.string().max(255).nullish(),
  transfer_method: z.string().max(64).nullish(),
  type: z.string().max(64).nullish(),
  upload_file_id: z.string().max(255).nullish(),
  url: z.string().nullish(),
})

/**
 * WorkflowNodeJobMetadata
 */
export const zWorkflowNodeJobMetadata = z.object({
  agent_soul: z.record(z.string(), z.unknown()).nullish(),
  file_refs: z.array(zAgentFileRefConfig).nullish(),
})

/**
 * OutputErrorStrategy
 *
 * Per-output failure handling strategy.
 *
 * Mirrors ``graphon.ErrorStrategy`` but scoped to a single declared output of
 * a Workflow Agent Node. The runtime applies the strategy after type check or
 * output check fails and any configured retry attempts have been exhausted.
 */
export const zOutputErrorStrategy = z.enum(['default_value', 'fail_branch', 'stop'])

/**
 * DeclaredOutputRetryConfig
 *
 * Per-output retry configuration that mirrors ``graphon.RetryConfig`` shape.
 */
export const zDeclaredOutputRetryConfig = z.object({
  enabled: z.boolean().optional().default(false),
  max_retries: z.int().gte(0).lte(10).optional().default(0),
  retry_interval_ms: z.int().gte(0).lte(60000).optional().default(0),
})

/**
 * DeclaredOutputFailureStrategy
 *
 * Per-output failure handling.
 *
 * A single strategy applies to both ``type_check`` and ``output_check`` failures
 * (PRD does not distinguish them at the UX level). Stage 4 §4.4.
 */
export const zDeclaredOutputFailureStrategy = z.object({
  default_value: z.unknown().optional(),
  on_failure: zOutputErrorStrategy.optional().default('stop'),
  retry: zDeclaredOutputRetryConfig.optional(),
})

/**
 * WorkflowOutputRoute
 *
 * Stable workflow exit identity and its model-visible selection condition.
 */
export const zWorkflowOutputRoute = z.object({
  id: z.string().min(1),
  label: z.string().nullish(),
  name: z.string().optional().default(''),
})

/**
 * WorkflowOutputRoutes
 *
 * Enabled routes require at least two exits; drafts may omit conditions.
 */
export const zWorkflowOutputRoutes = z.object({
  enabled: z.boolean().optional().default(false),
  routes: z.array(zWorkflowOutputRoute).optional(),
})

/**
 * AgentCliToolAuthorizationStatus
 *
 * Authorization state for Agent-scoped CLI tools.
 *
 * Missing status keeps backward compatibility with draft rows and CLI tools that
 * do not need pre-authorization. Explicit denied-like states are blocked by the
 * composer/publish validators and skipped by runtime request builders.
 */
export const zAgentCliToolAuthorizationStatus = z.enum([
  'allowed',
  'authorized',
  'denied',
  'forbidden',
  'not_required',
  'pending',
  'pre_authorized',
  'unauthorized',
])

/**
 * AgentPermissionConfig
 */
export const zAgentPermissionConfig = z.object({
  allowed: z.boolean().nullish(),
  state: z.string().max(64).nullish(),
  status: z.string().max(64).nullish(),
})

/**
 * AgentSecretRefConfig
 */
export const zAgentSecretRefConfig = z.object({
  credential_id: z.string().max(255).nullish(),
  env_name: z.string().max(255).nullish(),
  id: z.string().max(255).nullish(),
  key: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  permission: zAgentPermissionConfig.nullish(),
  permission_status: z.string().max(64).nullish(),
  provider: z.string().max(255).nullish(),
  provider_credential_id: z.string().max(255).nullish(),
  ref: z.string().max(255).nullish(),
  type: z.string().max(64).nullish(),
  value: z.string().nullish(),
  variable: z.string().max(255).nullish(),
})

/**
 * AgentSoulEnvConfig
 */
export const zAgentSoulEnvConfig = z.object({
  secret_refs: z.array(zAgentSecretRefConfig).optional(),
  variables: z.array(zAgentEnvVariableConfig).optional(),
})

/**
 * AgentCliToolEnvConfig
 */
export const zAgentCliToolEnvConfig = z.object({
  secret_refs: z.array(zAgentSecretRefConfig).optional(),
  variables: z.array(zAgentEnvVariableConfig).optional(),
})

/**
 * AgentCliToolRiskLevel
 *
 * Risk marker for CLI tool bootstrap commands.
 */
export const zAgentCliToolRiskLevel = z.enum(['dangerous', 'safe', 'unknown'])

/**
 * AgentCliToolConfig
 */
export const zAgentCliToolConfig = z.object({
  approved: z.boolean().optional().default(false),
  authorization_status: zAgentCliToolAuthorizationStatus.nullish(),
  command: z.string().nullish(),
  dangerous: z.boolean().optional().default(false),
  dangerous_accepted: z.boolean().optional().default(false),
  dangerous_acknowledged: z.boolean().optional().default(false),
  dangerous_command: z.boolean().optional().default(false),
  description: z.string().nullish(),
  enabled: z.boolean().optional().default(true),
  env: zAgentCliToolEnvConfig.optional(),
  id: z.string().max(255).nullish(),
  inferred_from: z.string().max(255).nullish(),
  install: z.string().nullish(),
  install_command: z.string().nullish(),
  install_commands: z.array(z.string()).optional(),
  invoke_metadata: z.record(z.string(), z.unknown()).optional(),
  label: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  permission: zAgentPermissionConfig.nullish(),
  pre_authorized: z.boolean().nullish(),
  requires_confirmation: z.boolean().optional().default(false),
  risk_accepted: z.boolean().optional().default(false),
  risk_level: zAgentCliToolRiskLevel.nullish(),
  setup_command: z.string().nullish(),
  tool_name: z.string().max(255).nullish(),
})

/**
 * AgentComposerKnowledgeDatasetCandidateResponse
 */
export const zAgentComposerKnowledgeDatasetCandidateResponse = z.object({
  description: z.string().nullish(),
  id: z.string().max(255).nullish(),
  missing: z.boolean().optional().default(false),
  name: z.string().max(255).nullish(),
})

/**
 * AgentComposerKnowledgeSetCandidateResponse
 */
export const zAgentComposerKnowledgeSetCandidateResponse = z.object({
  control_space_id: z.string().nullish(),
  datasets: z.array(zAgentComposerKnowledgeDatasetCandidateResponse).optional(),
  description: z.string().nullish(),
  id: z.string(),
  missing: z.boolean().optional().default(false),
  missing_dataset_ids: z.array(z.string()).optional(),
  name: z.string(),
})

/**
 * AgentComposerSoulCandidatesResponse
 */
export const zAgentComposerSoulCandidatesResponse = z.object({
  cli_tools: z.array(zAgentCliToolConfig).optional(),
  dify_tools: z.array(zAgentComposerDifyToolCandidateResponse).optional(),
  human_contacts: z.array(zAgentHumanContactConfig).optional(),
  knowledge_sets: z.array(zAgentComposerKnowledgeSetCandidateResponse).optional(),
})

/**
 * AgentComposerCandidatesResponse
 */
export const zAgentComposerCandidatesResponse = z.object({
  allowed_node_job_candidates: zAgentComposerNodeJobCandidatesResponse.optional(),
  allowed_soul_candidates: zAgentComposerSoulCandidatesResponse.optional(),
  capabilities: zComposerCandidateCapabilities.optional(),
  truncated: z.boolean().optional().default(false),
  variant: zComposerVariant,
})

/**
 * ToolProviderType
 *
 * Enum class for tool provider
 */
export const zToolProviderType = z.enum([
  'api',
  'app',
  'builtin',
  'dataset-retrieval',
  'mcp',
  'plugin',
  'workflow',
])

/**
 * AppProviderAgentToolResponse
 */
export const zAppProviderAgentToolResponse = z.object({
  credential_id: z.string().nullish(),
  enabled: z.boolean().optional(),
  isDeleted: z.boolean().optional(),
  notAuthor: z.boolean().optional(),
  plugin_unique_identifier: z.string().nullish(),
  provider_id: z.string(),
  provider_name: z.string().optional(),
  provider_type: zToolProviderType,
  tool_label: z.string().optional(),
  tool_name: z.string(),
  tool_parameters: z.record(z.string(), zJsonValue),
})

/**
 * AppProviderAgentToolPayload
 */
export const zAppProviderAgentToolPayload = z
  .object({
    credential_id: z.string().nullish(),
    enabled: z.boolean().nullish(),
    isDeleted: z.boolean().optional(),
    notAuthor: z.boolean().optional(),
    plugin_unique_identifier: z.string().nullish(),
    provider_id: z.string(),
    provider_name: z.string().optional(),
    provider_type: zToolProviderType,
    tool_label: z.string().optional(),
    tool_name: z.string(),
    tool_parameters: z.record(z.string(), zAppConfigJsonValue),
  })
  .catchall(z.json())

/**
 * AppDatasetReferenceResponse
 */
export const zAppDatasetReferenceResponse = z.object({
  enabled: z.boolean().optional(),
  id: z.string().optional(),
})

/**
 * AppLegacyDatasetToolResponse
 */
export const zAppLegacyDatasetToolResponse = z.object({
  dataset: zAppDatasetReferenceResponse,
})

/**
 * AppLegacySensitiveWordToolResponse
 */
export const zAppLegacySensitiveWordToolResponse = z.object({
  canned_response: z.string(),
  enabled: z.boolean(),
  words: z.array(z.string()),
})

/**
 * AppLegacySensitiveWordToolResponseItem
 */
export const zAppLegacySensitiveWordToolResponseItem = z.object({
  'sensitive-word-avoidance': zAppLegacySensitiveWordToolResponse,
})

/**
 * AppAgentModeResponse
 */
export const zAppAgentModeResponse = z.object({
  enabled: z.boolean(),
  max_iteration: z.int().optional(),
  prompt: z.union([zAppAgentPromptResponse, z.string()]).nullish(),
  strategy: z.union([zPlanningStrategy, z.enum(['cot', 'function-calling'])]).nullish(),
  tools: z
    .array(
      z.union([
        zAppProviderAgentToolResponse,
        zAppLegacyDatasetToolResponse,
        zAppLegacyGoogleSearchToolResponse,
        zAppLegacyWebReaderToolResponse,
        zAppLegacyWikipediaToolResponse,
        zAppLegacyCurrentDatetimeToolResponse,
        zAppLegacySensitiveWordToolResponseItem,
      ]),
    )
    .optional(),
})

/**
 * AppDatasetItemResponse
 */
export const zAppDatasetItemResponse = z.object({
  dataset: zAppDatasetReferenceResponse,
})

/**
 * AppDatasetListResponse
 */
export const zAppDatasetListResponse = z.object({
  datasets: z.array(zAppDatasetItemResponse),
  strategy: z.string().optional(),
})

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

/**
 * AppMetadataFilteringConditionsResponse
 */
export const zAppMetadataFilteringConditionsResponse = z.object({
  conditions: z.array(zAppMetadataConditionResponse).nullish(),
  logical_operator: z.enum(['and', 'or']).nullish(),
})

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

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

/**
 * AppWeightsResponse
 */
export const zAppWeightsResponse = z.object({
  keyword_setting: zAppKeywordSettingResponse,
  vector_setting: zAppVectorSettingResponse,
  weight_type: z.enum(['customized', 'keyword_first', 'semantic_first']).optional(),
})

/**
 * AppDatasetConfigsResponse
 */
export const zAppDatasetConfigsResponse = z.object({
  datasets: zAppDatasetListResponse.optional(),
  metadata_filtering_conditions: zAppMetadataFilteringConditionsResponse.nullish(),
  metadata_filtering_mode: z.enum(['automatic', 'disabled', 'manual']).optional(),
  metadata_model_config: zAppModelSelectionResponse.nullish(),
  reranking_enable: z.boolean().optional(),
  reranking_enabled: z.boolean().optional(),
  reranking_mode: zRerankMode.optional(),
  reranking_model: zAppRerankingModelResponse.nullish(),
  retrieval_model: z.enum(['multiple', 'single']),
  score_threshold: z.number().nullish(),
  score_threshold_enabled: z.boolean().optional(),
  top_k: z.int().optional(),
  weights: zAppWeightsResponse.nullish(),
})

/**
 * AppModelConfigResponse
 */
export const zAppModelConfigResponse = z.object({
  agent_mode: zAppAgentModeResponse,
  annotation_reply: z.union([
    zAppAnnotationReplyEnabledResponse,
    zAppAnnotationReplyDisabledResponse,
  ]),
  chat_prompt_config: zAppChatPromptConfigResponse,
  completion_prompt_config: zAppCompletionPromptConfigResponse,
  created_at: z.int(),
  created_by: z.string().nullable(),
  dataset_configs: zAppDatasetConfigsResponse,
  dataset_query_variable: z.string().nullable(),
  external_data_tools: z.array(
    z.union([zAppEnabledExternalDataToolResponse, zAppDisabledExternalDataToolResponse]),
  ),
  file_upload: zAppFileUploadResponse,
  model: zAppModelSelectionResponse,
  more_like_this: zAppEnabledConfigResponse,
  opening_statement: z.string().nullable(),
  pre_prompt: z.string().nullable(),
  prompt_type: zPromptType,
  retriever_resource: zAppEnabledConfigResponse,
  sensitive_word_avoidance: zAppSensitiveWordAvoidanceResponse,
  speech_to_text: zAppEnabledConfigResponse,
  suggested_questions: z.array(z.string()),
  suggested_questions_after_answer: zAppSuggestedQuestionsAfterAnswerResponse,
  text_to_speech: zAppTextToSpeechResponse,
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  user_input_form: z.array(
    z.union([
      zAppTextInputFormResponse,
      zAppSelectFormResponse,
      zAppParagraphFormResponse,
      zAppNumberFormResponse,
      zAppCheckboxFormResponse,
      zAppFileFormResponse,
      zAppFileListFormResponse,
      zAppExternalDataToolFormResponse,
      zAppJsonObjectFormResponse,
    ]),
  ),
})

/**
 * AppDetailWithSite
 */
export const zAppDetailWithSite = z.object({
  access_mode: zWebAppAccessMode.nullable(),
  api_base_url: z.string(),
  app_id: z.string().nullable(),
  bound_agent_id: z.string().nullable(),
  created_at: z.int(),
  created_by: z.string().nullable(),
  deleted_tools: z.array(zDeletedTool),
  description: z.string(),
  enable_api: z.boolean(),
  enable_site: z.boolean(),
  icon: z.string().nullable(),
  icon_background: z.string().nullable(),
  icon_type: zIconType.nullable(),
  icon_url: z.string().nullable(),
  id: z.string(),
  maintainer: z.string().nullable(),
  max_active_requests: z.int().nullable(),
  mode: zAppMode,
  model_config: zAppModelConfigResponse.nullable(),
  name: z.string(),
  permission_keys: z.array(z.string()),
  site: zAppDetailSiteResponse.nullable(),
  tags: z.array(zTag),
  tracing: z.string().nullable(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  use_icon_as_answer_icon: z.boolean(),
  workflow: zWorkflowPartial.nullable(),
})

/**
 * AppDetail
 */
export const zAppDetail = z.object({
  access_mode: zWebAppAccessMode.nullable(),
  created_at: z.int(),
  created_by: z.string().nullable(),
  description: z.string(),
  enable_api: z.boolean(),
  enable_site: z.boolean(),
  icon: z.string().nullable(),
  icon_background: z.string().nullable(),
  id: z.string(),
  maintainer: z.string().nullable(),
  mode: zAppMode,
  model_config: zAppModelConfigResponse.nullable(),
  name: z.string(),
  permission_keys: z.array(z.string()),
  tags: z.array(zTag),
  tracing: z.string().nullable(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  use_icon_as_answer_icon: z.boolean(),
  workflow: zWorkflowPartial.nullable(),
})

/**
 * 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,
  zSelectInputConfig,
  zFileInputConfig,
  zFileListInputConfig,
])

/**
 * HumanInputFormPreviewResponse
 */
export const zHumanInputFormPreviewResponse = z.object({
  actions: z.array(zUserActionConfig).optional(),
  display_in_ui: z.boolean().nullish(),
  expiration_time: z.int().nullish(),
  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(),
})

/**
 * 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(),
  form_version: z.enum(['1', '2']).optional().default('1'),
  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(),
})

/**
 * MessageDetailResponse
 */
export const zMessageDetailResponse = z.object({
  agent_thoughts: z.array(zAgentThought),
  annotation: zConversationAnnotation.nullish(),
  annotation_hit_history: zConversationAnnotationHitHistory.nullish(),
  answer: z.string(),
  answer_tokens: z.int(),
  conversation_id: z.string(),
  created_at: z.int().nullish(),
  error: z.string().nullish(),
  extra_contents: z.array(zHumanInputContent).optional(),
  feedbacks: z.array(zFeedback),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  inputs: z.record(z.string(), zAnyJsonValue),
  message: zAnyJsonValue,
  message_files: z.array(zMessageFile),
  message_tokens: z.int(),
  metadata: zAnyJsonValue,
  parent_message_id: z.string().nullish(),
  provider_response_latency: z.number(),
  query: z.string(),
  retriever_resources: z.array(zRetrievalSourceMetadata).optional(),
  status: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * MessageInfiniteScrollPaginationResponse
 */
export const zMessageInfiniteScrollPaginationResponse = z.object({
  data: z.array(zMessageDetailResponse),
  has_more: z.boolean(),
  limit: z.int(),
})

/**
 * AppLegacyDatasetSelectionPayload
 */
export const zAppLegacyDatasetSelectionPayload = z
  .object({
    enabled: z.boolean().nullish(),
    id: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppLegacyDatasetToolPayload
 */
export const zAppLegacyDatasetToolPayload = z
  .object({
    dataset: zAppLegacyDatasetSelectionPayload,
  })
  .catchall(z.json())

/**
 * AppLegacySensitiveWordConfigPayload
 */
export const zAppLegacySensitiveWordConfigPayload = z
  .object({
    canned_response: z.string(),
    enabled: z.boolean(),
    words: z.array(z.string()),
  })
  .catchall(z.json())

/**
 * AppLegacySensitiveWordToolPayload
 */
export const zAppLegacySensitiveWordToolPayload = z
  .object({
    'sensitive-word-avoidance': zAppLegacySensitiveWordConfigPayload,
  })
  .catchall(z.json())

export const zAppAgentToolPayload = z.union([
  zAppProviderAgentToolPayload,
  zAppLegacyDatasetToolPayload,
  zAppLegacyGoogleSearchToolPayload,
  zAppLegacyWebReaderToolPayload,
  zAppLegacyWikipediaToolPayload,
  zAppLegacyCurrentDatetimeToolPayload,
  zAppLegacySensitiveWordToolPayload,
])

/**
 * AppAgentModePayload
 */
export const zAppAgentModePayload = z
  .object({
    enabled: z.boolean().nullish(),
    max_iteration: z.int().optional(),
    prompt: z.union([zAppAgentPromptPayload, z.string()]).nullish(),
    strategy: z.union([zPlanningStrategy, z.enum(['', 'cot', 'function-calling'])]).nullish(),
    tools: z.array(zAppAgentToolPayload).nullish(),
  })
  .catchall(z.json())

/**
 * AppDatasetSelectionPayload
 */
export const zAppDatasetSelectionPayload = z
  .object({
    enabled: z.boolean().optional(),
    id: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppDatasetToolPayload
 */
export const zAppDatasetToolPayload = z
  .object({
    dataset: zAppDatasetSelectionPayload,
  })
  .catchall(z.json())

/**
 * AppDatasetCollectionPayload
 */
export const zAppDatasetCollectionPayload = z
  .object({
    datasets: z.array(zAppDatasetToolPayload),
    strategy: z.string().optional(),
  })
  .catchall(z.json())

/**
 * AppDatasetConfigPayload
 */
export const zAppDatasetConfigPayload = z
  .object({
    datasets: z.union([zAppDatasetCollectionPayload, zAppEmptyDatasetCollectionPayload]).nullish(),
    metadata_filtering_conditions: zAppMetadataFilteringPayload.nullish(),
    metadata_filtering_mode: z.enum(['automatic', 'disabled', 'manual']).optional(),
    metadata_model_config: zAppMetadataModelPayload.nullish(),
    reranking_enable: z.boolean().optional(),
    reranking_enabled: z.boolean().optional(),
    reranking_mode: zRerankMode.optional(),
    reranking_model: zAppRerankingModelPayload.nullish(),
    retrieval_model: z.enum(['multiple', 'single']).optional(),
    score_threshold: z.number().nullish(),
    score_threshold_enabled: z.boolean().optional(),
    top_k: z.int().optional(),
    weights: zAppRetrievalWeightsPayload.nullish(),
  })
  .catchall(z.json())

/**
 * AppModelConfigPayload
 *
 * Write transport; app-mode validators own defaults and feature-specific rules.
 */
export const zAppModelConfigPayload = z.object({
  agent_mode: zAppAgentModePayload.nullish(),
  chat_prompt_config: zAppChatPromptPayload.nullish(),
  completion_prompt_config: zAppCompletionPromptPayload.nullish(),
  dataset_configs: zAppDatasetConfigPayload.nullish(),
  dataset_query_variable: z.string().nullish(),
  external_data_tools: z.array(zAppExternalDataToolPayload).nullish(),
  file_upload: zAppFileUploadPayload.nullish(),
  model: zAppModelSelectionPayload,
  more_like_this: zAppFeaturePayload.nullish(),
  opening_statement: z.string().nullish(),
  pre_prompt: z.string().nullish(),
  prompt_type: z.enum(['', 'advanced', 'simple']).nullish(),
  retriever_resource: zAppFeaturePayload.nullish(),
  sensitive_word_avoidance: zAppModerationPayload.nullish(),
  speech_to_text: zAppFeaturePayload.nullish(),
  suggested_questions: z.array(z.string()).nullish(),
  suggested_questions_after_answer: zAppSuggestedQuestionsPayload.nullish(),
  text_to_speech: zAppTextToSpeechPayload.nullish(),
  user_input_form: z.array(zAppUserInputFormPayload).nullish(),
})

/**
 * AgentFileUploadImageFeatureConfig
 */
export const zAgentFileUploadImageFeatureConfig = z.object({
  enabled: z.boolean().optional().default(true),
})

/**
 * AgentFileUploadFeatureConfig
 */
export const zAgentFileUploadFeatureConfig = 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(),
  enabled: z.boolean().optional().default(true),
  image: zAgentFileUploadImageFeatureConfig.optional(),
  number_limits: z.int().optional().default(3),
})

/**
 * AgentSuggestedQuestionsAfterAnswerModelConfig
 *
 * Legacy Chat App model config used only for follow-up question generation.
 */
export const zAgentSuggestedQuestionsAfterAnswerModelConfig = z.object({
  completion_params: z.record(z.string(), z.unknown()).nullish(),
  mode: z.string().max(64).nullish(),
  name: z.string().min(1).max(255),
  provider: z.string().min(1).max(255),
})

/**
 * AgentSuggestedQuestionsAfterAnswerFeatureConfig
 */
export const zAgentSuggestedQuestionsAfterAnswerFeatureConfig = z.object({
  enabled: z.boolean().optional().default(false),
  model: zAgentSuggestedQuestionsAfterAnswerModelConfig.nullish(),
  prompt: z.string().nullish(),
})

/**
 * AgentKnowledgeDatasetConfig
 */
export const zAgentKnowledgeDatasetConfig = z.object({
  description: z.string().nullish(),
  id: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
})

/**
 * AgentModelResponseFormatConfig
 */
export const zAgentModelResponseFormatConfig = z.object({
  type: z.string().max(64).nullish(),
})

/**
 * AgentSoulModelSettings
 *
 * Model parameters for the Agent Soul model.
 *
 * Model plugins can declare arbitrary parameters via ``parameter_rules``
 * (e.g. Qwen/Tongyi's ``enable_thinking``) beyond the common OpenAI-style
 * fields typed below, so extra keys must round-trip through persistence
 * rather than being dropped.
 */
export const zAgentSoulModelSettings = z.object({
  frequency_penalty: z.number().nullish(),
  max_tokens: z.int().nullish(),
  presence_penalty: z.number().nullish(),
  response_format: z.union([z.string(), zAgentModelResponseFormatConfig]).nullish(),
  stop: z.array(z.string()).nullish(),
  temperature: z.number().nullish(),
  top_p: z.number().nullish(),
})

/**
 * AgentSoulModelConfig
 *
 * Stable model selection for Agent runtime without storing secret values.
 */
export const zAgentSoulModelConfig = z.object({
  credential_ref: zAgentSoulModelCredentialRef.nullish(),
  model: z.string().min(1).max(255),
  model_provider: z.string().min(1).max(255),
  model_settings: zAgentSoulModelSettings.optional(),
  plugin_id: z.string().min(1).max(255),
})

/**
 * DeclaredOutputCheckConfig
 *
 * File-output content check via a model-based comparison against a benchmark file.
 *
 * Per the PRD output configuration section, output checks are **file-only** and optional. Stage 4 §4.3.
 */
export const zDeclaredOutputCheckConfig = z.object({
  benchmark_file_ref: zAgentFileRefConfig.nullish(),
  enabled: z.boolean().optional().default(false),
  model_ref: zAgentSoulModelConfig.nullish(),
  prompt: z.string().nullish(),
})

/**
 * DeclaredOutputConfig
 *
 * One declared output of a Workflow Agent Node.
 *
 * Stage 4 normalizes the shape: ``check`` is singular (was ``checks: list`` in
 * stage 3), and ``failure_strategy`` defaults to a populated value so runtime
 * code can call ``output.failure_strategy.on_failure`` without None-guards.
 */
export const zDeclaredOutputConfig = z.object({
  array_item: zDeclaredArrayItem.nullish(),
  check: zDeclaredOutputCheckConfig.nullish(),
  children: z
    .array(
      z.object({
        array_item: z
          .object({
            children: z.array(z.record(z.string(), z.unknown())).optional(),
            description: z.string().nullish(),
            type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']).optional(),
          })
          .nullish(),
        children: z.array(z.record(z.string(), z.unknown())).optional(),
        description: z.string().nullish(),
        file: z.record(z.string(), z.unknown()).nullish(),
        name: z.string(),
        required: z.boolean().optional(),
        type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']),
      }),
    )
    .optional(),
  description: z.string().nullish(),
  failure_strategy: zDeclaredOutputFailureStrategy.optional(),
  file: zDeclaredOutputFileConfig.nullish(),
  id: z.string().nullish(),
  name: z.string().min(1).max(255),
  required: z.boolean().optional().default(true),
  type: zDeclaredOutputType,
})

/**
 * WorkflowNodeJobConfig
 */
export const zWorkflowNodeJobConfig = z.object({
  declared_outputs: z.array(zDeclaredOutputConfig).optional(),
  human_contacts: z.array(zAgentHumanContactConfig).optional(),
  metadata: zWorkflowNodeJobMetadata.optional(),
  mode: zWorkflowNodeJobMode.optional().default('tell_agent_what_to_do'),
  output_routes: zWorkflowOutputRoutes.optional(),
  previous_node_output_refs: z.array(zWorkflowPreviousNodeOutputRef).optional(),
  schema_version: z.int().optional().default(1),
  workflow_prompt: z.string().optional().default(''),
})

/**
 * AgentSoulDifyToolCredentialRef
 *
 * Reference to a stored Dify Plugin Tool credential.
 *
 * Secret values are resolved only at runtime. The legacy ``credential_id``
 * field is accepted by :class:`AgentSoulDifyToolConfig` and normalized here so
 * old Agent tool payloads can be read while new payloads stay explicit.
 */
export const zAgentSoulDifyToolCredentialRef = z.object({
  id: z.string().max(255).nullish(),
  provider: z.string().max(255).nullish(),
  type: z.enum(['provider', 'tool']).optional().default('tool'),
})

/**
 * AgentSoulDifyToolConfig
 *
 * One Dify tool configured on Agent Soul.
 *
 * The API backend prepares this persisted product shape into
 * either ``DifyPluginToolConfig`` or ``DifyCoreToolConfig`` before sending a
 * run request to Agent backend. ``plugin`` providers keep the direct
 * ``dify.plugin.tools`` transport; ``builtin`` / ``api`` / ``workflow`` /
 * ``mcp`` providers are prepared for ``dify.core.tools``. ``provider_id``
 * keeps compatibility with existing Agent tool config payloads; new callers
 * should send ``plugin_id`` + ``provider`` when available.
 */
export const zAgentSoulDifyToolConfig = z.object({
  credential_ref: zAgentSoulDifyToolCredentialRef.nullish(),
  credential_type: z.enum(['api-key', 'oauth2', 'unauthorized']).optional().default('api-key'),
  description: z.string().nullish(),
  enabled: z.boolean().optional().default(true),
  name: z.string().max(255).nullish(),
  plugin_id: z.string().max(255).nullish(),
  provider: z.string().max(255).nullish(),
  provider_id: z.string().max(255).nullish(),
  provider_type: zToolProviderType,
  runtime_parameters: z
    .record(
      z.string(),
      z
        .union([
          z.string(),
          z.int(),
          z.number(),
          z.boolean(),
          z.array(z.string()),
          z.array(z.int()),
          z.array(z.number()),
          z.array(z.boolean()),
        ])
        .nullable(),
    )
    .optional(),
  tool_name: z.string().min(1).max(255).nullish(),
})

/**
 * AgentSoulToolsConfig
 */
export const zAgentSoulToolsConfig = z.object({
  cli_tools: z.array(zAgentCliToolConfig).optional(),
  dify_tools: z.array(zAgentSoulDifyToolConfig).optional(),
})

/**
 * AgentModerationIOConfig
 */
export const zAgentModerationIoConfig = z.object({
  enabled: z.boolean().optional().default(false),
  preset_response: z.string().nullish(),
})

/**
 * AgentModerationProviderConfig
 */
export const zAgentModerationProviderConfig = z.object({
  api_based_extension_id: z.string().nullish(),
  inputs_config: zAgentModerationIoConfig.nullish(),
  keywords: z.string().nullish(),
  outputs_config: zAgentModerationIoConfig.nullish(),
})

/**
 * AgentSensitiveWordAvoidanceFeatureConfig
 */
export const zAgentSensitiveWordAvoidanceFeatureConfig = z.object({
  config: zAgentModerationProviderConfig.nullish(),
  enabled: z.boolean().optional().default(false),
  type: z.string().nullish(),
})

/**
 * AgentSoulAppFeaturesConfig
 */
export const zAgentSoulAppFeaturesConfig = z.object({
  file_upload: zAgentFileUploadFeatureConfig.optional(),
  opening_statement: z.string().nullish(),
  retriever_resource: zAgentFeatureToggleConfig.nullish(),
  sensitive_word_avoidance: zAgentSensitiveWordAvoidanceFeatureConfig.nullish(),
  show_thoughts: zAgentFeatureToggleConfig.nullish(),
  speech_to_text: zAgentFeatureToggleConfig.nullish(),
  suggested_questions: z.array(z.string()).nullish(),
  suggested_questions_after_answer: zAgentSuggestedQuestionsAfterAnswerFeatureConfig.nullish(),
  text_to_speech: zAgentTextToSpeechFeatureConfig.nullish(),
})

/**
 * AgentKnowledgeModelConfig
 */
export const zAgentKnowledgeModelConfig = z.object({
  completion_params: z.record(z.string(), z.unknown()).optional(),
  mode: z.string().min(1).max(64),
  name: z.string().min(1).max(255),
  provider: z.string().min(1).max(255),
})

/**
 * AgentKnowledgeQueryMode
 */
export const zAgentKnowledgeQueryMode = z.enum(['generated_query', 'user_query'])

/**
 * AgentKnowledgeQueryConfig
 *
 * Per-set query policy for Agent v2 knowledge retrieval.
 *
 * Agent v2 stores knowledge as explicit ``knowledge.sets`` rather than the
 * legacy flat ``datasets`` / ``query_mode`` / ``query_config`` shape. Each
 * set owns its own query policy. Mode-dependent completeness, such as
 * requiring ``value`` for ``user_query``, is enforced by composer publish
 * validation so draft saves can persist partially configured knowledge sets.
 */
export const zAgentKnowledgeQueryConfig = z.object({
  mode: zAgentKnowledgeQueryMode,
  value: z.string().nullish(),
})

/**
 * AgentKnowledgeRerankingModelConfig
 */
export const zAgentKnowledgeRerankingModelConfig = z.object({
  model: z.string().min(1).max(255),
  provider: z.string().min(1).max(255),
})

/**
 * AgentKnowledgeWeightedScoreConfig
 */
export const zAgentKnowledgeWeightedScoreConfig = z.object({
  keyword_setting: z.record(z.string(), z.unknown()).nullish(),
  vector_setting: z.record(z.string(), z.unknown()).nullish(),
  weight_type: z.string().max(64).nullish(),
})

/**
 * AgentKnowledgeRetrievalConfig
 *
 * Per-set retrieval policy for Agent v2 knowledge retrieval.
 *
 * Retrieval settings now live on each knowledge set instead of one shared
 * flat config. Mode-dependent completeness, such as requiring ``top_k`` for
 * ``multiple`` or a model for ``single``, is enforced by composer publish
 * validation so draft saves can persist partially configured knowledge sets.
 */
export const zAgentKnowledgeRetrievalConfig = z.object({
  mode: z.enum(['multiple', 'single']),
  model: zAgentKnowledgeModelConfig.nullish(),
  reranking_enable: z.boolean().optional().default(true),
  reranking_mode: z.string().optional().default('reranking_model'),
  reranking_model: zAgentKnowledgeRerankingModelConfig.nullish(),
  score_threshold: z.number().gte(0).lte(1).nullish(),
  top_k: z.int().gte(1).nullish(),
  weights: zAgentKnowledgeWeightedScoreConfig.nullish(),
})

/**
 * AgentKnowledgeMetadataCondition
 *
 * One manual metadata filter clause.
 *
 * ``id`` and ``metadata_id`` are UI-only bookkeeping the composer sends on
 * every save (a stable row key and a reference to the selected metadata
 * field). They are persisted here for round-tripping the composer's draft
 * state but are stripped before building the Agent runtime request, whose
 * DTO only accepts ``name``/``comparison_operator``/``value``.
 */
export const zAgentKnowledgeMetadataCondition = z.object({
  comparison_operator: z.enum([
    '<',
    '=',
    '>',
    'after',
    'before',
    'contains',
    'empty',
    'end with',
    'in',
    'is',
    'is not',
    'not contains',
    'not empty',
    'not in',
    'start with',
    '≠',
    '≤',
    '≥',
  ]),
  id: z.string().nullish(),
  metadata_id: z.string().nullish(),
  name: z.string().min(1).max(255),
  value: z.union([z.string(), z.array(z.string()), z.number()]).nullish(),
})

/**
 * AgentKnowledgeMetadataConditions
 */
export const zAgentKnowledgeMetadataConditions = z.object({
  conditions: z.array(zAgentKnowledgeMetadataCondition).optional(),
  logical_operator: z.enum(['and', 'or']).optional().default('and'),
})

/**
 * AgentKnowledgeMetadataFilteringConfig
 *
 * Per-set metadata filtering policy.
 *
 * The Python attribute uses ``metadata_model_config`` for clarity because the
 * model belongs to metadata filtering specifically, while the external API and
 * generated schema keep the historical ``model_config`` field name via alias.
 * Mode-dependent completeness is enforced by composer publish validation so
 * draft saves can persist partially configured metadata filters.
 */
export const zAgentKnowledgeMetadataFilteringConfig = z.object({
  conditions: zAgentKnowledgeMetadataConditions.nullish(),
  mode: z.enum(['automatic', 'disabled', 'manual']).optional().default('disabled'),
  model_config: zAgentKnowledgeModelConfig.nullish(),
})

/**
 * AgentKnowledgeSetConfig
 *
 * One explicit knowledge set in Agent v2.
 *
 * ``knowledge.sets`` replaces the old flat knowledge config. Each set owns
 * its datasets plus query, retrieval, and metadata policies. An individual
 * set must contain at least one dataset id even though the overall knowledge
 * section may be empty, which is how callers express "no knowledge layer".
 */
export const zAgentKnowledgeSetConfig = z.object({
  datasets: z.array(zAgentKnowledgeDatasetConfig),
  description: z.string().nullish(),
  id: z.string().min(1).max(255),
  metadata_filtering: zAgentKnowledgeMetadataFilteringConfig.optional(),
  name: z.string().min(1).max(255),
  query: zAgentKnowledgeQueryConfig,
  retrieval: zAgentKnowledgeRetrievalConfig,
})

/**
 * AgentSoulKnowledgeConfig
 *
 * Agent Knowledge Base and Classic Knowledge Base bindings for an Agent.
 *
 * ``spaces`` use the KnowledgeFS layer and ``sets`` use the Classic Knowledge
 * Base layer. Both may be configured together; empty knowledge adds no runtime
 * capability.
 */
export const zAgentSoulKnowledgeConfig = z.object({
  sets: z.array(zAgentKnowledgeSetConfig).optional(),
  spaces: z.array(zAgentKnowledgeSpaceConfig).max(10).optional(),
})

/**
 * AgentSoulConfig
 */
export const zAgentSoulConfig = z.object({
  app_features: zAgentSoulAppFeaturesConfig.optional(),
  app_variables: z.array(zAppVariableConfig).optional(),
  config_files: z.array(zAgentConfigFileRefConfig).optional(),
  config_note: z.string().optional().default(''),
  config_skills: z.array(zAgentConfigSkillRefConfig).optional(),
  env: zAgentSoulEnvConfig.optional(),
  human: zAgentSoulHumanConfig.optional(),
  knowledge: zAgentSoulKnowledgeConfig.optional(),
  memory: zAgentSoulMemoryConfig.optional(),
  misc_legacy: zAgentSoulAppFeaturesConfig.optional(),
  model: zAgentSoulModelConfig.nullish(),
  prompt: zAgentSoulPromptConfig.optional(),
  sandbox: zAgentSoulSandboxConfig.optional(),
  schema_version: z.int().optional().default(1),
  tools: zAgentSoulToolsConfig.optional(),
})

/**
 * WorkflowAgentComposerResponse
 */
export const zWorkflowAgentComposerResponse = z.object({
  active_config_snapshot: zAgentConfigSnapshotSummaryResponse.nullish(),
  agent: zAgentComposerAgentResponse.nullish(),
  agent_soul: zAgentSoulConfig,
  app_id: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  binding: zAgentComposerBindingResponse.nullish(),
  chat_endpoint: z.string().nullish(),
  debug_conversation_has_messages: z.boolean().optional().default(false),
  debug_conversation_id: z.string().nullish(),
  debug_conversation_message_count: z.int().optional().default(0),
  effective_declared_outputs: z.array(zDeclaredOutputConfig).optional(),
  hidden_app_backed: z.boolean().optional().default(false),
  impact_summary: zAgentComposerImpactResponse.nullish(),
  node_id: z.string().nullish(),
  node_job: zWorkflowNodeJobConfig,
  save_options: z.array(zComposerSaveStrategy),
  soul_lock: zAgentComposerSoulLockResponse,
  validation: zComposerValidationFindingsResponse.nullish(),
  variant: z.literal('workflow'),
  workflow_id: z.string().nullish(),
})

/**
 * ComposerSavePayload
 */
export const zComposerSavePayload = z.object({
  agent_soul: zAgentSoulConfig.nullish(),
  binding: zComposerBindingPayload.nullish(),
  client_revision_id: z.string().nullish(),
  description: z.string().nullish(),
  icon: z.string().max(255).nullish(),
  icon_background: z.string().max(255).nullish(),
  icon_type: zAgentIconType.nullish(),
  idempotency_key: z.string().nullish(),
  new_agent_name: z.string().min(1).max(255).nullish(),
  node_job: zWorkflowNodeJobConfig.nullish(),
  role: z.string().max(255).nullish(),
  save_strategy: zComposerSaveStrategy,
  soul_lock: zComposerSoulLockPayload.optional(),
  variant: zComposerVariant,
  version_note: z.string().nullish(),
})

/**
 * MessageTemplateTestResponse
 *
 * Response body returned after one message-template test send.
 */
export const zMessageTemplateTestResponseWritable = z.record(z.string(), z.unknown())

/**
 * GeneratedAppResponse
 */
export const zGeneratedAppResponseWritable = zShallowJsonValue

/**
 * AppPartial
 */
export const zAppPartialWritable = z.object({
  access_mode: zWebAppAccessMode.nullish(),
  app_id: z.string().nullish(),
  author_name: z.string().nullish(),
  bound_agent_id: z.string().nullish(),
  create_user_name: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  description: z.string().nullish(),
  has_draft_trigger: z.boolean().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  id: z.string(),
  is_starred: z.boolean().optional().default(false),
  maintainer: z.string().nullish(),
  max_active_requests: z.int().nullish(),
  mode: zAppMode,
  model_config: zModelConfigPartial.nullish(),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  tags: z.array(zTag).optional(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
  workflow: zWorkflowPartial.nullish(),
})

/**
 * AppPagination
 */
export const zAppPaginationWritable = z.object({
  data: z.array(zAppPartialWritable),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * AppDetailSiteResponse
 */
export const zAppDetailSiteResponseWritable = z.object({
  access_token: z.string().nullable(),
  app_base_url: z.string(),
  chat_color_theme: z.string().nullable(),
  chat_color_theme_inverted: z.boolean(),
  code: z.string().nullable(),
  copyright: z.string().nullable(),
  created_at: z.int(),
  created_by: z.string().nullable(),
  custom_disclaimer: z.string(),
  customize_domain: z.string().nullable(),
  customize_token_strategy: zCustomizeTokenStrategy,
  default_language: z.string(),
  description: z.string().nullable(),
  icon: z.string().nullable(),
  icon_background: z.string().nullable(),
  icon_type: zIconType.nullable(),
  input_placeholder: z.string().nullable(),
  privacy_policy: z.string().nullable(),
  prompt_public: z.boolean(),
  show_workflow_steps: z.boolean(),
  title: z.string(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  use_icon_as_answer_icon: z.boolean(),
})

/**
 * AppDetailWithSite
 */
export const zAppDetailWithSiteWritable = z.object({
  access_mode: zWebAppAccessMode.nullable(),
  api_base_url: z.string(),
  app_id: z.string().nullable(),
  bound_agent_id: z.string().nullable(),
  created_at: z.int(),
  created_by: z.string().nullable(),
  deleted_tools: z.array(zDeletedTool),
  description: z.string(),
  enable_api: z.boolean(),
  enable_site: z.boolean(),
  icon: z.string().nullable(),
  icon_background: z.string().nullable(),
  icon_type: zIconType.nullable(),
  id: z.string(),
  maintainer: z.string().nullable(),
  max_active_requests: z.int().nullable(),
  mode: zAppMode,
  model_config: zAppModelConfigResponse.nullable(),
  name: z.string(),
  permission_keys: z.array(z.string()),
  site: zAppDetailSiteResponseWritable.nullable(),
  tags: z.array(zTag),
  tracing: z.string().nullable(),
  updated_at: z.int(),
  updated_by: z.string().nullable(),
  use_icon_as_answer_icon: z.boolean(),
  workflow: zWorkflowPartial.nullable(),
})

/**
 * RecentAppResponse
 */
export const zRecentAppResponseWritable = z.object({
  author_name: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  id: z.string(),
  maintainer: z.string().nullish(),
  mode: z.enum(['advanced-chat', 'agent-chat', 'chat', 'completion', 'workflow']),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  updated_at: z.int(),
})

/**
 * RecentAppListResponse
 */
export const zRecentAppListResponseWritable = z.object({
  data: z.array(zRecentAppResponseWritable),
})

/**
 * AccountWithRoleResponse
 */
export const zAccountWithRoleResponseWritable = z.object({
  avatar: z.string().nullish(),
  created_at: z.int().nullish(),
  email: z.string(),
  id: z.string(),
  last_active_at: z.int().nullish(),
  last_login_at: z.int().nullish(),
  name: z.string(),
  role: z.string(),
  roles: z.array(zMemberRoleSummaryResponse).optional(),
  status: z.string(),
})

/**
 * WorkflowCommentMentionUsersPayload
 */
export const zWorkflowCommentMentionUsersPayloadWritable = z.object({
  users: z.array(zAccountWithRoleResponseWritable),
})

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

/**
 * WorkflowCommentBasic
 */
export const zWorkflowCommentBasicWritable = z.object({
  content: z.string(),
  created_at: z.int().nullish(),
  created_by: z.string(),
  created_by_account: zWorkflowCommentAccountWritable.nullish(),
  id: z.string(),
  mention_count: z.int(),
  participants: z.array(zWorkflowCommentAccountWritable),
  position_x: z.number(),
  position_y: z.number(),
  reply_count: z.int(),
  resolved: z.boolean(),
  resolved_at: z.int().nullish(),
  resolved_by: z.string().nullish(),
  resolved_by_account: zWorkflowCommentAccountWritable.nullish(),
  updated_at: z.int().nullish(),
})

/**
 * WorkflowCommentBasicList
 */
export const zWorkflowCommentBasicListWritable = z.object({
  data: z.array(zWorkflowCommentBasicWritable),
})

/**
 * WorkflowCommentMention
 */
export const zWorkflowCommentMentionWritable = z.object({
  mentioned_user_account: zWorkflowCommentAccountWritable.nullish(),
  mentioned_user_id: z.string(),
  reply_id: z.string().nullish(),
})

/**
 * WorkflowCommentReply
 */
export const zWorkflowCommentReplyWritable = z.object({
  content: z.string(),
  created_at: z.int().nullish(),
  created_by: z.string(),
  created_by_account: zWorkflowCommentAccountWritable.nullish(),
  id: z.string(),
})

/**
 * WorkflowCommentDetail
 */
export const zWorkflowCommentDetailWritable = z.object({
  content: z.string(),
  created_at: z.int().nullish(),
  created_by: z.string(),
  created_by_account: zWorkflowCommentAccountWritable.nullish(),
  id: z.string(),
  mentions: z.array(zWorkflowCommentMentionWritable),
  position_x: z.number(),
  position_y: z.number(),
  replies: z.array(zWorkflowCommentReplyWritable),
  resolved: z.boolean(),
  resolved_at: z.int().nullish(),
  resolved_by: z.string().nullish(),
  resolved_by_account: zWorkflowCommentAccountWritable.nullish(),
  updated_at: z.int().nullish(),
})

export const zRecursiveJsonValueWritable = z
  .union([
    z.string(),
    z.int(),
    z.number(),
    z.boolean(),
    z.record(
      z.string(),
      z.lazy((): any => zRecursiveJsonValueWritable),
    ),
    z.array(z.lazy((): any => zRecursiveJsonValueWritable)),
  ])
  .nullable()

export const zAppConfigJsonValueWritable = z.json().nullable()

/**
 * AppEmptyDatasetCollectionPayload
 */
export const zAppEmptyDatasetCollectionPayloadWritable = z.record(z.string(), z.never())

export const zGetAppsQuery = z.object({
  creator_ids: z.array(z.string()).optional(),
  is_created_by_me: z.boolean().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  mode: z
    .enum([
      'advanced-chat',
      'agent',
      'agent-chat',
      'all',
      'channel',
      'chat',
      'completion',
      'workflow',
    ])
    .optional()
    .default('all'),
  name: z.string().optional(),
  openapi_visible: z.boolean().optional().default(false),
  page: z.int().gte(1).lte(99999).optional().default(1),
  sort_by: z
    .enum(['earliest_created', 'last_modified', 'recently_created'])
    .optional()
    .default('last_modified'),
  tag_ids: z.array(z.string()).optional(),
})

/**
 * Success
 */
export const zGetAppsResponse = zAppPagination

export const zPostAppsBody = zCreateAppPayload

/**
 * App created successfully
 */
export const zPostAppsResponse = zAppDetailWithSite

export const zPostAppsImportsBody = z.union([
  zAppImportPayload,
  z.object({
    app_id: z.string().optional(),
    description: z.string().optional(),
    file: z.custom<Blob | File>((value) => value instanceof Blob || value instanceof File),
    icon: z.string().optional(),
    icon_background: z.string().optional(),
    icon_type: z.string().optional(),
    name: z.string().optional(),
  }),
])

/**
 * Import completed
 */
export const zPostAppsImportsResponse = zImport

export const zGetAppsImportsByAppIdCheckDependenciesPath = z.object({
  app_id: z.string(),
})

/**
 * Dependencies checked
 */
export const zGetAppsImportsByAppIdCheckDependenciesResponse = zCheckDependenciesResult

export const zPostAppsImportsByImportIdConfirmPath = z.object({
  import_id: z.string(),
})

/**
 * Import confirmed
 */
export const zPostAppsImportsByImportIdConfirmResponse = zImport

export const zGetAppsRecentQuery = z.object({
  limit: z.int().gte(1).lte(8).optional().default(8),
})

/**
 * Success
 */
export const zGetAppsRecentResponse = zRecentAppListResponse

export const zGetAppsStarredQuery = z.object({
  creator_ids: z.array(z.string()).optional(),
  is_created_by_me: z.boolean().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  mode: z
    .enum([
      'advanced-chat',
      'agent',
      'agent-chat',
      'all',
      'channel',
      'chat',
      'completion',
      'workflow',
    ])
    .optional()
    .default('all'),
  name: z.string().optional(),
  openapi_visible: z.boolean().optional().default(false),
  page: z.int().gte(1).lte(99999).optional().default(1),
  sort_by: z
    .enum(['earliest_created', 'last_modified', 'recently_created'])
    .optional()
    .default('last_modified'),
  tag_ids: z.array(z.string()).optional(),
})

/**
 * Success
 */
export const zGetAppsStarredResponse = zAppPagination

export const zPostAppsWorkflowsOnlineUsersBody = zWorkflowOnlineUsersPayload

/**
 * Workflow online users retrieved successfully
 */
export const zPostAppsWorkflowsOnlineUsersResponse = zWorkflowOnlineUsersResponse

export const zDeleteAppsByAppIdPath = z.object({
  app_id: z.uuid(),
})

/**
 * App deleted successfully
 */
export const zDeleteAppsByAppIdResponse = z.void()

export const zGetAppsByAppIdPath = z.object({
  app_id: z.uuid(),
})

/**
 * Success
 */
export const zGetAppsByAppIdResponse = zAppDetailWithSite

export const zPutAppsByAppIdBody = zUpdateAppPayload

export const zPutAppsByAppIdPath = z.object({
  app_id: z.uuid(),
})

/**
 * App updated successfully
 */
export const zPutAppsByAppIdResponse = zAppDetailWithSite

export const zGetAppsByAppIdAdvancedChatWorkflowRunsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdAdvancedChatWorkflowRunsQuery = z.object({
  last_id: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  status: z.enum(['failed', 'partial-succeeded', 'running', 'stopped', 'succeeded']).optional(),
  triggered_from: z.enum(['app-run', 'debugging']).optional(),
})

/**
 * Workflow runs retrieved successfully
 */
export const zGetAppsByAppIdAdvancedChatWorkflowRunsResponse =
  zAdvancedChatWorkflowRunPaginationResponse

export const zGetAppsByAppIdAdvancedChatWorkflowRunsCountPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdAdvancedChatWorkflowRunsCountQuery = z.object({
  status: z.enum(['failed', 'partial-succeeded', 'running', 'stopped', 'succeeded']).optional(),
  time_range: z.string().optional(),
  triggered_from: z.enum(['app-run', 'debugging']).optional(),
})

/**
 * Workflow runs count retrieved successfully
 */
export const zGetAppsByAppIdAdvancedChatWorkflowRunsCountResponse = zWorkflowRunCountResponse

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdFormPreviewBody =
  zHumanInputFormPreviewPayload

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdFormPreviewPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
  })

/**
 * Human input form preview
 */
export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdFormPreviewResponse =
  zHumanInputFormPreviewResponse

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdFormRunBody =
  zHumanInputFormPreviewSubmitPayload

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdFormRunPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
  })

/**
 * Human input form submission result
 */
export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdFormRunResponse =
  zHumanInputFormSubmitResponse

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdMessageTemplateTestBody =
  zMessageTemplateTestRequest

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdMessageTemplateTestPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
  })

/**
 * Success
 */
export const zPostAppsByAppIdAdvancedChatWorkflowsDraftHumanInputNodesByNodeIdMessageTemplateTestResponse =
  zMessageTemplateTestResponse

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftIterationNodesByNodeIdRunBody =
  zIterationNodeRunPayload

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftIterationNodesByNodeIdRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Iteration node run started successfully
 */
export const zPostAppsByAppIdAdvancedChatWorkflowsDraftIterationNodesByNodeIdRunResponse =
  zGeneratedAppResponse

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftLoopNodesByNodeIdRunBody =
  zLoopNodeRunPayload

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftLoopNodesByNodeIdRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Loop node run started successfully
 */
export const zPostAppsByAppIdAdvancedChatWorkflowsDraftLoopNodesByNodeIdRunResponse =
  zGeneratedAppResponse

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftRunBody = zAdvancedChatWorkflowRunPayload

export const zPostAppsByAppIdAdvancedChatWorkflowsDraftRunPath = z.object({
  app_id: z.uuid(),
})

/**
 * Workflow run started successfully
 */
export const zPostAppsByAppIdAdvancedChatWorkflowsDraftRunResponse = zGeneratedAppResponse

export const zGetAppsByAppIdAgentConfigFilesPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdAgentConfigFilesQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config files
 */
export const zGetAppsByAppIdAgentConfigFilesResponse = zAgentConfigFileListResponse

export const zPostAppsByAppIdAgentConfigFilesBody = zAgentConfigFileUploadPayload

export const zPostAppsByAppIdAgentConfigFilesPath = z.object({
  app_id: z.uuid(),
})

export const zPostAppsByAppIdAgentConfigFilesQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Uploaded config file
 */
export const zPostAppsByAppIdAgentConfigFilesResponse = zAgentConfigFileUploadResponse

export const zPostAppsByAppIdAgentConfigFilesBatchBody = zAgentConfigFilesUploadPayload

export const zPostAppsByAppIdAgentConfigFilesBatchPath = z.object({
  app_id: z.uuid(),
})

export const zPostAppsByAppIdAgentConfigFilesBatchQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Bound config files
 */
export const zPostAppsByAppIdAgentConfigFilesBatchResponse = zAgentConfigFilesUploadResponse

export const zDeleteAppsByAppIdAgentConfigFilesByNamePath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zDeleteAppsByAppIdAgentConfigFilesByNameQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config file deleted
 */
export const zDeleteAppsByAppIdAgentConfigFilesByNameResponse = zAgentConfigDeleteResponse

export const zGetAppsByAppIdAgentConfigFilesByNameDownloadPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zGetAppsByAppIdAgentConfigFilesByNameDownloadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config file download URL
 */
export const zGetAppsByAppIdAgentConfigFilesByNameDownloadResponse = zAgentConfigDownloadResponse

export const zGetAppsByAppIdAgentConfigFilesByNamePreviewPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zGetAppsByAppIdAgentConfigFilesByNamePreviewQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Preview
 */
export const zGetAppsByAppIdAgentConfigFilesByNamePreviewResponse = zAgentConfigFilePreviewResponse

export const zGetAppsByAppIdAgentConfigManifestPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdAgentConfigManifestQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Agent config manifest
 */
export const zGetAppsByAppIdAgentConfigManifestResponse = zAgentConfigManifestResponse

export const zGetAppsByAppIdAgentConfigSkillsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdAgentConfigSkillsQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config skills
 */
export const zGetAppsByAppIdAgentConfigSkillsResponse = zAgentConfigSkillListResponse

export const zPostAppsByAppIdAgentConfigSkillsUploadBody = z.object({
  file: z.custom<Blob | File>((value) => value instanceof Blob || value instanceof File),
})

export const zPostAppsByAppIdAgentConfigSkillsUploadPath = z.object({
  app_id: z.uuid(),
})

export const zPostAppsByAppIdAgentConfigSkillsUploadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Uploaded config skill
 */
export const zPostAppsByAppIdAgentConfigSkillsUploadResponse = zAgentConfigSkillUploadResponse

export const zDeleteAppsByAppIdAgentConfigSkillsByNamePath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zDeleteAppsByAppIdAgentConfigSkillsByNameQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config skill deleted
 */
export const zDeleteAppsByAppIdAgentConfigSkillsByNameResponse = zAgentConfigDeleteResponse

export const zGetAppsByAppIdAgentConfigSkillsByNameDownloadPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zGetAppsByAppIdAgentConfigSkillsByNameDownloadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config skill download URL
 */
export const zGetAppsByAppIdAgentConfigSkillsByNameDownloadResponse = zAgentConfigDownloadResponse

export const zGetAppsByAppIdAgentConfigSkillsByNameFilesContentPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

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

export const zGetAppsByAppIdAgentConfigSkillsByNameFilesDownloadPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zGetAppsByAppIdAgentConfigSkillsByNameFilesDownloadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  path: z.string(),
  version_id: z.string().optional(),
})

/**
 * Config skill file download URL
 */
export const zGetAppsByAppIdAgentConfigSkillsByNameFilesDownloadResponse =
  zAgentConfigDownloadResponse

export const zGetAppsByAppIdAgentConfigSkillsByNameFilesPreviewPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zGetAppsByAppIdAgentConfigSkillsByNameFilesPreviewQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  path: z.string(),
  version_id: z.string().optional(),
})

/**
 * Config skill file preview
 */
export const zGetAppsByAppIdAgentConfigSkillsByNameFilesPreviewResponse =
  zAgentConfigSkillFilePreviewResponse

export const zGetAppsByAppIdAgentConfigSkillsByNameInspectPath = z.object({
  app_id: z.uuid(),
  name: z.string(),
})

export const zGetAppsByAppIdAgentConfigSkillsByNameInspectQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  node_id: z.string().optional(),
  version_id: z.string().optional(),
})

/**
 * Config skill inspect view
 */
export const zGetAppsByAppIdAgentConfigSkillsByNameInspectResponse =
  zAgentConfigSkillInspectResponse

export const zGetAppsByAppIdAgentLogsPath = z.object({
  app_id: z.uuid(),
})

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

/**
 * Agent logs retrieved successfully
 */
export const zGetAppsByAppIdAgentLogsResponse = zAgentLogResponse

export const zPostAppsByAppIdAnnotationReplyByActionBody = zAnnotationReplyPayload

export const zPostAppsByAppIdAnnotationReplyByActionPath = z.object({
  action: z.string(),
  app_id: z.uuid(),
})

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

export const zGetAppsByAppIdAnnotationReplyByActionStatusByJobIdPath = z.object({
  action: z.string(),
  app_id: z.uuid(),
  job_id: z.uuid(),
})

/**
 * Job status retrieved successfully
 */
export const zGetAppsByAppIdAnnotationReplyByActionStatusByJobIdResponse =
  zAnnotationJobStatusDetailResponse

export const zGetAppsByAppIdAnnotationSettingPath = z.object({
  app_id: z.uuid(),
})

/**
 * Annotation settings retrieved successfully
 */
export const zGetAppsByAppIdAnnotationSettingResponse = zAnnotationSettingResponse

export const zPostAppsByAppIdAnnotationSettingsByAnnotationSettingIdBody =
  zAnnotationSettingUpdatePayload

export const zPostAppsByAppIdAnnotationSettingsByAnnotationSettingIdPath = z.object({
  annotation_setting_id: z.uuid(),
  app_id: z.uuid(),
})

/**
 * Settings updated successfully
 */
export const zPostAppsByAppIdAnnotationSettingsByAnnotationSettingIdResponse =
  zAnnotationSettingResponse

export const zDeleteAppsByAppIdAnnotationsPath = z.object({
  app_id: z.uuid(),
})

export const zDeleteAppsByAppIdAnnotationsQuery = z.object({
  annotation_id: z.array(z.string()).optional(),
})

/**
 * Annotations deleted successfully
 */
export const zDeleteAppsByAppIdAnnotationsResponse = z.void()

export const zGetAppsByAppIdAnnotationsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdAnnotationsQuery = 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 zGetAppsByAppIdAnnotationsResponse = zAnnotationList

export const zPostAppsByAppIdAnnotationsBody = zCreateAnnotationPayload

export const zPostAppsByAppIdAnnotationsPath = z.object({
  app_id: z.uuid(),
})

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

export const zPostAppsByAppIdAnnotationsBatchImportPath = z.object({
  app_id: z.uuid(),
})

/**
 * Import started, or CSV/subscription validation failed (error_msg)
 */
export const zPostAppsByAppIdAnnotationsBatchImportResponse = zAnnotationBatchImportResponse

export const zGetAppsByAppIdAnnotationsBatchImportStatusByJobIdPath = z.object({
  app_id: z.uuid(),
  job_id: z.uuid(),
})

/**
 * Job status retrieved successfully
 */
export const zGetAppsByAppIdAnnotationsBatchImportStatusByJobIdResponse =
  zAnnotationJobStatusDetailResponse

export const zGetAppsByAppIdAnnotationsCountPath = z.object({
  app_id: z.uuid(),
})

/**
 * Annotation count retrieved successfully
 */
export const zGetAppsByAppIdAnnotationsCountResponse = zAnnotationCountResponse

export const zGetAppsByAppIdAnnotationsExportPath = z.object({
  app_id: z.uuid(),
})

/**
 * Annotations exported successfully
 */
export const zGetAppsByAppIdAnnotationsExportResponse = zAnnotationExportList

export const zDeleteAppsByAppIdAnnotationsByAnnotationIdPath = z.object({
  annotation_id: z.uuid(),
  app_id: z.uuid(),
})

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

export const zPostAppsByAppIdAnnotationsByAnnotationIdBody = zUpdateAnnotationPayload

export const zPostAppsByAppIdAnnotationsByAnnotationIdPath = z.object({
  annotation_id: z.uuid(),
  app_id: z.uuid(),
})

export const zPostAppsByAppIdAnnotationsByAnnotationIdResponse = z.union([zAnnotation, z.void()])

export const zGetAppsByAppIdAnnotationsByAnnotationIdHitHistoriesPath = z.object({
  annotation_id: z.uuid(),
  app_id: z.uuid(),
})

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

/**
 * Hit histories retrieved successfully
 */
export const zGetAppsByAppIdAnnotationsByAnnotationIdHitHistoriesResponse =
  zAnnotationHitHistoryList

export const zPostAppsByAppIdApiEnableBody = zAppApiStatusPayload

export const zPostAppsByAppIdApiEnablePath = z.object({
  app_id: z.uuid(),
})

/**
 * API status updated successfully
 */
export const zPostAppsByAppIdApiEnableResponse = zAppDetail

export const zPostAppsByAppIdAudioToTextBody = z.object({
  file: z.custom<Blob | File>((value) => value instanceof Blob || value instanceof File),
})

export const zPostAppsByAppIdAudioToTextPath = z.object({
  app_id: z.uuid(),
})

/**
 * Audio transcription successful
 */
export const zPostAppsByAppIdAudioToTextResponse = zAudioTranscriptResponse

export const zGetAppsByAppIdChatConversationsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdChatConversationsQuery = z.object({
  annotation_status: z.enum(['all', 'annotated', 'not_annotated']).optional().default('all'),
  end: 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),
  sort_by: z
    .enum(['-created_at', '-updated_at', 'created_at', 'updated_at'])
    .optional()
    .default('-updated_at'),
  start: z.string().optional(),
})

/**
 * Success
 */
export const zGetAppsByAppIdChatConversationsResponse = zConversationWithSummaryPagination

export const zDeleteAppsByAppIdChatConversationsByConversationIdPath = z.object({
  app_id: z.uuid(),
  conversation_id: z.uuid(),
})

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

export const zGetAppsByAppIdChatConversationsByConversationIdPath = z.object({
  app_id: z.uuid(),
  conversation_id: z.uuid(),
})

/**
 * Success
 */
export const zGetAppsByAppIdChatConversationsByConversationIdResponse = zConversationDetail

export const zGetAppsByAppIdChatMessagesPath = z.object({
  app_id: z.uuid(),
})

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

/**
 * Success
 */
export const zGetAppsByAppIdChatMessagesResponse = zMessageInfiniteScrollPaginationResponse

export const zGetAppsByAppIdChatMessagesByMessageIdSuggestedQuestionsPath = z.object({
  app_id: z.uuid(),
  message_id: z.uuid(),
})

/**
 * Suggested questions retrieved successfully
 */
export const zGetAppsByAppIdChatMessagesByMessageIdSuggestedQuestionsResponse =
  zSuggestedQuestionsResponse

export const zPostAppsByAppIdChatMessagesByTaskIdStopPath = z.object({
  app_id: z.uuid(),
  task_id: z.string(),
})

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

export const zGetAppsByAppIdCompletionConversationsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdCompletionConversationsQuery = z.object({
  annotation_status: z.enum(['all', 'annotated', 'not_annotated']).optional().default('all'),
  end: 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),
  start: z.string().optional(),
})

/**
 * Success
 */
export const zGetAppsByAppIdCompletionConversationsResponse = zConversationPagination

export const zDeleteAppsByAppIdCompletionConversationsByConversationIdPath = z.object({
  app_id: z.uuid(),
  conversation_id: z.uuid(),
})

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

export const zGetAppsByAppIdCompletionConversationsByConversationIdPath = z.object({
  app_id: z.uuid(),
  conversation_id: z.uuid(),
})

/**
 * Success
 */
export const zGetAppsByAppIdCompletionConversationsByConversationIdResponse =
  zConversationMessageDetail

export const zPostAppsByAppIdCompletionMessagesBody = zCompletionMessagePayload

export const zPostAppsByAppIdCompletionMessagesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Completion generated successfully
 */
export const zPostAppsByAppIdCompletionMessagesResponse = z.record(z.string(), z.unknown())

export const zPostAppsByAppIdCompletionMessagesByTaskIdStopPath = z.object({
  app_id: z.uuid(),
  task_id: z.string(),
})

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

export const zGetAppsByAppIdConversationVariablesPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdConversationVariablesQuery = z.object({
  conversation_id: z.string(),
})

/**
 * Conversation variables retrieved successfully
 */
export const zGetAppsByAppIdConversationVariablesResponse = zPaginatedConversationVariableResponse

export const zPostAppsByAppIdConvertToWorkflowBody = zConvertToWorkflowPayload

export const zPostAppsByAppIdConvertToWorkflowPath = z.object({
  app_id: z.uuid(),
})

/**
 * Application converted to workflow successfully
 */
export const zPostAppsByAppIdConvertToWorkflowResponse = zNewAppResponse

export const zPostAppsByAppIdCopyBody = zCopyAppPayload

export const zPostAppsByAppIdCopyPath = z.object({
  app_id: z.uuid(),
})

export const zPostAppsByAppIdCopyResponse = z.union([zAppDetailWithSite, zAppImportResponse])

export const zGetAppsByAppIdExportPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdExportQuery = z.object({
  format: z.enum(['ifpkg', 'yaml']).optional(),
  include_secret: z.boolean().optional().default(false),
  version_id: z.uuid().optional(),
  workflow_id: z.string().optional(),
})

/**
 * App exported successfully
 */
export const zGetAppsByAppIdExportResponse = z.union([
  zAppExportResponse,
  z.custom<Blob | File>((value) => value instanceof Blob || value instanceof File),
])

export const zPostAppsByAppIdFeedbacksBody = zAppMessageFeedbackPayload

export const zPostAppsByAppIdFeedbacksPath = z.object({
  app_id: z.uuid(),
})

/**
 * Feedback updated successfully
 */
export const zPostAppsByAppIdFeedbacksResponse = zSimpleResultResponse

export const zPostAppsByAppIdIconBody = zAppIconPayload

export const zPostAppsByAppIdIconPath = z.object({
  app_id: z.uuid(),
})

/**
 * Icon updated successfully
 */
export const zPostAppsByAppIdIconResponse = zAppDetail

export const zGetAppsByAppIdMessagesByMessageIdPath = z.object({
  app_id: z.uuid(),
  message_id: z.uuid(),
})

/**
 * Message retrieved successfully
 */
export const zGetAppsByAppIdMessagesByMessageIdResponse = zMessageDetailResponse

export const zPostAppsByAppIdModelConfigBody = zAppModelConfigPayload

export const zPostAppsByAppIdModelConfigPath = z.object({
  app_id: z.uuid(),
})

/**
 * Model configuration updated successfully
 */
export const zPostAppsByAppIdModelConfigResponse = zSimpleResultResponse

export const zPostAppsByAppIdNameBody = zAppNamePayload

export const zPostAppsByAppIdNamePath = z.object({
  app_id: z.uuid(),
})

/**
 * Name availability checked
 */
export const zPostAppsByAppIdNameResponse = zAppDetail

export const zGetAppsByAppIdNetworkAccessGroupPath = z.object({
  app_id: z.uuid(),
})

/**
 * App network access group binding retrieved successfully
 */
export const zGetAppsByAppIdNetworkAccessGroupResponse = zAppNetworkAccessGroupResponse

export const zPutAppsByAppIdNetworkAccessGroupBody = zAppNetworkAccessGroupUpdatePayload

export const zPutAppsByAppIdNetworkAccessGroupPath = z.object({
  app_id: z.uuid(),
})

/**
 * App network access group binding updated successfully
 */
export const zPutAppsByAppIdNetworkAccessGroupResponse = zAppNetworkAccessGroupMutationResponse

export const zGetAppsByAppIdNetworkAccessGroupStatusPath = z.object({
  app_id: z.uuid(),
})

/**
 * App network access control entry status retrieved successfully
 */
export const zGetAppsByAppIdNetworkAccessGroupStatusResponse = zAppNetworkAccessGroupStatusResponse

export const zPostAppsByAppIdPublishToCreatorsPlatformPath = z.object({
  app_id: z.uuid(),
})

/**
 * Success
 */
export const zPostAppsByAppIdPublishToCreatorsPlatformResponse = zRedirectUrlResponse

export const zGetAppsByAppIdServerPath = z.object({
  app_id: z.uuid(),
})

/**
 * MCP server configuration retrieved successfully
 */
export const zGetAppsByAppIdServerResponse = zAppMcpServerResponse

export const zPostAppsByAppIdServerBody = zMcpServerCreatePayload

export const zPostAppsByAppIdServerPath = z.object({
  app_id: z.uuid(),
})

/**
 * MCP server configuration created successfully
 */
export const zPostAppsByAppIdServerResponse = zAppMcpServerResponse

export const zPutAppsByAppIdServerBody = zMcpServerUpdatePayload

export const zPutAppsByAppIdServerPath = z.object({
  app_id: z.uuid(),
})

/**
 * MCP server configuration updated successfully
 */
export const zPutAppsByAppIdServerResponse = zAppMcpServerResponse

export const zPostAppsByAppIdServerRefreshPath = z.object({
  app_id: z.uuid(),
})

/**
 * MCP server refreshed successfully
 */
export const zPostAppsByAppIdServerRefreshResponse = zAppMcpServerResponse

export const zPostAppsByAppIdSiteBody = zAppSiteUpdatePayload

export const zPostAppsByAppIdSitePath = z.object({
  app_id: z.uuid(),
})

/**
 * Site configuration updated successfully
 */
export const zPostAppsByAppIdSiteResponse = zAppSiteResponse

export const zPostAppsByAppIdSiteEnableBody = zAppSiteStatusPayload

export const zPostAppsByAppIdSiteEnablePath = z.object({
  app_id: z.uuid(),
})

/**
 * Site status updated successfully
 */
export const zPostAppsByAppIdSiteEnableResponse = zAppDetail

export const zPostAppsByAppIdSiteAccessTokenResetPath = z.object({
  app_id: z.uuid(),
})

/**
 * Access token reset successfully
 */
export const zPostAppsByAppIdSiteAccessTokenResetResponse = zAppSiteResponse

export const zDeleteAppsByAppIdStarPath = z.object({
  app_id: z.uuid(),
})

/**
 * Success
 */
export const zDeleteAppsByAppIdStarResponse = zSimpleResultResponse

export const zPostAppsByAppIdStarPath = z.object({
  app_id: z.uuid(),
})

/**
 * Success
 */
export const zPostAppsByAppIdStarResponse = zSimpleResultResponse

export const zGetAppsByAppIdStatisticsAverageResponseTimePath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsAverageResponseTimeQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Average response time statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsAverageResponseTimeResponse =
  zAverageResponseTimeStatisticResponse

export const zGetAppsByAppIdStatisticsAverageSessionInteractionsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsAverageSessionInteractionsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Average session interaction statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsAverageSessionInteractionsResponse =
  zAverageSessionInteractionStatisticResponse

export const zGetAppsByAppIdStatisticsDailyConversationsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsDailyConversationsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily conversation statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsDailyConversationsResponse =
  zDailyConversationStatisticResponse

export const zGetAppsByAppIdStatisticsDailyEndUsersPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsDailyEndUsersQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily terminal statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsDailyEndUsersResponse = zDailyTerminalStatisticResponse

export const zGetAppsByAppIdStatisticsDailyMessagesPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsDailyMessagesQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily message statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsDailyMessagesResponse = zDailyMessageStatisticResponse

export const zGetAppsByAppIdStatisticsTokenCostsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsTokenCostsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily token cost statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsTokenCostsResponse = zDailyTokenCostStatisticResponse

export const zGetAppsByAppIdStatisticsTokensPerSecondPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsTokensPerSecondQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Tokens per second statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsTokensPerSecondResponse = zTokensPerSecondStatisticResponse

export const zGetAppsByAppIdStatisticsUserSatisfactionRatePath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdStatisticsUserSatisfactionRateQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * User satisfaction rate statistics retrieved successfully
 */
export const zGetAppsByAppIdStatisticsUserSatisfactionRateResponse =
  zUserSatisfactionRateStatisticResponse

export const zPostAppsByAppIdTextToAudioBody = zTextToSpeechPayload

export const zPostAppsByAppIdTextToAudioPath = z.object({
  app_id: z.uuid(),
})

/**
 * Text to speech conversion successful
 */
export const zPostAppsByAppIdTextToAudioResponse = z.record(z.string(), z.unknown())

export const zGetAppsByAppIdTextToAudioVoicesPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdTextToAudioVoicesQuery = z.object({
  language: z.string(),
})

/**
 * TTS voices retrieved successfully
 */
export const zGetAppsByAppIdTextToAudioVoicesResponse = zTextToSpeechVoiceListResponse

export const zGetAppsByAppIdTracePath = z.object({
  app_id: z.uuid(),
})

/**
 * Trace configuration retrieved successfully
 */
export const zGetAppsByAppIdTraceResponse = zAppTraceResponse

export const zPostAppsByAppIdTraceBody = zAppTracePayload

export const zPostAppsByAppIdTracePath = z.object({
  app_id: z.uuid(),
})

/**
 * Trace configuration updated successfully
 */
export const zPostAppsByAppIdTraceResponse = zSimpleResultResponse

export const zGetAppsByAppIdTraceCapabilitiesPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdTraceCapabilitiesQuery = z.object({
  tracing_provider: z.string(),
})

/**
 * Provider support declarations
 */
export const zGetAppsByAppIdTraceCapabilitiesResponse = zTraceProviderCapabilitiesResponse

export const zDeleteAppsByAppIdTraceConfigPath = z.object({
  app_id: z.uuid(),
})

export const zDeleteAppsByAppIdTraceConfigQuery = z.object({
  tracing_provider: z.string(),
})

/**
 * Tracing configuration deleted successfully
 */
export const zDeleteAppsByAppIdTraceConfigResponse = z.void()

export const zGetAppsByAppIdTraceConfigPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdTraceConfigQuery = z.object({
  tracing_provider: z.string(),
})

/**
 * Tracing configuration retrieved successfully
 */
export const zGetAppsByAppIdTraceConfigResponse = zTraceAppConfigResponse

export const zPatchAppsByAppIdTraceConfigBody = zTraceConfigPayload

export const zPatchAppsByAppIdTraceConfigPath = z.object({
  app_id: z.uuid(),
})

/**
 * Tracing configuration updated successfully
 */
export const zPatchAppsByAppIdTraceConfigResponse = zTraceAppConfigResponse

export const zPostAppsByAppIdTraceConfigBody = zTraceConfigPayload

export const zPostAppsByAppIdTraceConfigPath = z.object({
  app_id: z.uuid(),
})

/**
 * Tracing configuration created successfully
 */
export const zPostAppsByAppIdTraceConfigResponse = zTraceAppConfigResponse

export const zGetAppsByAppIdTraceRunsBySourceKindBySourceIdPath = z.object({
  app_id: z.uuid(),
  source_id: z.uuid(),
  source_kind: z.enum(['message', 'node', 'workflow']),
})

export const zGetAppsByAppIdTraceRunsBySourceKindBySourceIdQuery = z.object({
  node_execution_id: z.uuid().optional(),
})

/**
 * Frozen trace destination and export state
 */
export const zGetAppsByAppIdTraceRunsBySourceKindBySourceIdResponse = zTraceRunStatusResponse

export const zPostAppsByAppIdTraceRunsBySourceKindBySourceIdRetryBody = zTraceRunRetryPayload

export const zPostAppsByAppIdTraceRunsBySourceKindBySourceIdRetryPath = z.object({
  app_id: z.uuid(),
  source_id: z.uuid(),
  source_kind: z.enum(['message', 'node', 'workflow']),
})

export const zPostAppsByAppIdTraceRunsBySourceKindBySourceIdRetryQuery = z.object({
  node_execution_id: z.uuid().optional(),
})

/**
 * Retry state for the same frozen destination
 */
export const zPostAppsByAppIdTraceRunsBySourceKindBySourceIdRetryResponse = zTraceRunStatusResponse

export const zPostAppsByAppIdTriggerEnableBody = zParserEnable

export const zPostAppsByAppIdTriggerEnablePath = z.object({
  app_id: z.uuid(),
})

/**
 * Success
 */
export const zPostAppsByAppIdTriggerEnableResponse = zWorkflowTriggerResponse

export const zGetAppsByAppIdTriggersPath = z.object({
  app_id: z.uuid(),
})

/**
 * Success
 */
export const zGetAppsByAppIdTriggersResponse = zWorkflowTriggerListResponse

export const zGetAppsByAppIdWorkflowAppLogsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowAppLogsQuery = z.object({
  created_at__after: z.iso.datetime().optional(),
  created_at__before: z.iso.datetime().optional(),
  created_by_account: z.string().optional(),
  created_by_end_user_session_id: z.string().optional(),
  detail: z.boolean().optional().default(false),
  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', 'partial-succeeded', 'paused', 'running', 'scheduled', 'stopped', 'succeeded'])
    .optional(),
})

/**
 * Workflow app logs retrieved successfully
 */
export const zGetAppsByAppIdWorkflowAppLogsResponse = zWorkflowAppLogPaginationResponse

export const zGetAppsByAppIdWorkflowRunsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowRunsQuery = z.object({
  last_id: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  status: z.enum(['failed', 'partial-succeeded', 'running', 'stopped', 'succeeded']).optional(),
  triggered_from: z.enum(['app-run', 'debugging']).optional(),
})

/**
 * Workflow runs retrieved successfully
 */
export const zGetAppsByAppIdWorkflowRunsResponse = zWorkflowRunPaginationResponse

export const zGetAppsByAppIdWorkflowRunsCountPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowRunsCountQuery = z.object({
  status: z.enum(['failed', 'partial-succeeded', 'running', 'stopped', 'succeeded']).optional(),
  time_range: z.string().optional(),
  triggered_from: z.enum(['app-run', 'debugging']).optional(),
})

/**
 * Workflow runs count retrieved successfully
 */
export const zGetAppsByAppIdWorkflowRunsCountResponse = zWorkflowRunCountResponse

export const zPostAppsByAppIdWorkflowRunsTasksByTaskIdStopPath = z.object({
  app_id: z.uuid(),
  task_id: z.string(),
})

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

export const zGetAppsByAppIdWorkflowRunsByRunIdPath = z.object({
  app_id: z.uuid(),
  run_id: z.uuid(),
})

/**
 * Workflow run detail retrieved successfully
 */
export const zGetAppsByAppIdWorkflowRunsByRunIdResponse = zWorkflowRunDetailResponse

export const zGetAppsByAppIdWorkflowRunsByRunIdNodeExecutionsPath = z.object({
  app_id: z.uuid(),
  run_id: z.uuid(),
})

/**
 * Node executions retrieved successfully
 */
export const zGetAppsByAppIdWorkflowRunsByRunIdNodeExecutionsResponse =
  zWorkflowRunNodeExecutionListResponse

export const zGetAppsByAppIdWorkflowRunsByRunIdNodeExecutionsByNodeExecutionIdChildrenPath =
  z.object({
    app_id: z.uuid(),
    node_execution_id: z.string(),
    run_id: z.uuid(),
  })

/**
 * Internal node executions retrieved successfully
 */
export const zGetAppsByAppIdWorkflowRunsByRunIdNodeExecutionsByNodeExecutionIdChildrenResponse =
  zWorkflowToolNodeExecutionListResponse

export const zGetAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
    workflow_run_id: z.uuid(),
  })

export const zGetAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesQuery =
  z.object({
    node_execution_id: z.string().min(1),
    path: z.string().optional().default('.'),
  })

/**
 * Listing returned
 */
export const zGetAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesResponse =
  zSandboxListResponse

export const zPostAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesDownloadBody =
  zWorkflowAgentSandboxDownloadPayload

export const zPostAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesDownloadPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
    workflow_run_id: z.uuid(),
  })

/**
 * Download URL returned
 */
export const zPostAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesDownloadResponse =
  zSandboxDownloadResponse

export const zGetAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesReadPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
    workflow_run_id: z.uuid(),
  })

export const zGetAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesReadQuery =
  z.object({
    node_execution_id: z.string().min(1),
    path: z.string().min(1),
  })

/**
 * Preview returned
 */
export const zGetAppsByAppIdWorkflowRunsByWorkflowRunIdAgentNodesByNodeIdSandboxFilesReadResponse =
  zSandboxReadResponse

export const zGetAppsByAppIdWorkflowCommentsPath = z.object({
  app_id: z.uuid(),
})

/**
 * Comments retrieved successfully
 */
export const zGetAppsByAppIdWorkflowCommentsResponse = zWorkflowCommentBasicList

export const zPostAppsByAppIdWorkflowCommentsBody = zWorkflowCommentCreatePayload

export const zPostAppsByAppIdWorkflowCommentsPath = z.object({
  app_id: z.uuid(),
})

/**
 * Comment created successfully
 */
export const zPostAppsByAppIdWorkflowCommentsResponse = zWorkflowCommentCreate

export const zGetAppsByAppIdWorkflowCommentsMentionUsersPath = z.object({
  app_id: z.uuid(),
})

/**
 * Mentionable users retrieved successfully
 */
export const zGetAppsByAppIdWorkflowCommentsMentionUsersResponse =
  zWorkflowCommentMentionUsersPayload

export const zDeleteAppsByAppIdWorkflowCommentsByCommentIdPath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
})

/**
 * Comment deleted successfully
 */
export const zDeleteAppsByAppIdWorkflowCommentsByCommentIdResponse = z.void()

export const zGetAppsByAppIdWorkflowCommentsByCommentIdPath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
})

/**
 * Comment retrieved successfully
 */
export const zGetAppsByAppIdWorkflowCommentsByCommentIdResponse = zWorkflowCommentDetail

export const zPutAppsByAppIdWorkflowCommentsByCommentIdBody = zWorkflowCommentUpdatePayload

export const zPutAppsByAppIdWorkflowCommentsByCommentIdPath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
})

/**
 * Comment updated successfully
 */
export const zPutAppsByAppIdWorkflowCommentsByCommentIdResponse = zWorkflowCommentUpdate

export const zPostAppsByAppIdWorkflowCommentsByCommentIdRepliesBody = zWorkflowCommentReplyPayload

export const zPostAppsByAppIdWorkflowCommentsByCommentIdRepliesPath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
})

/**
 * Reply created successfully
 */
export const zPostAppsByAppIdWorkflowCommentsByCommentIdRepliesResponse =
  zWorkflowCommentReplyCreate

export const zDeleteAppsByAppIdWorkflowCommentsByCommentIdRepliesByReplyIdPath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
  reply_id: z.string(),
})

/**
 * Reply deleted successfully
 */
export const zDeleteAppsByAppIdWorkflowCommentsByCommentIdRepliesByReplyIdResponse = z.void()

export const zPutAppsByAppIdWorkflowCommentsByCommentIdRepliesByReplyIdBody =
  zWorkflowCommentReplyPayload

export const zPutAppsByAppIdWorkflowCommentsByCommentIdRepliesByReplyIdPath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
  reply_id: z.string(),
})

/**
 * Reply updated successfully
 */
export const zPutAppsByAppIdWorkflowCommentsByCommentIdRepliesByReplyIdResponse =
  zWorkflowCommentReplyUpdate

export const zPostAppsByAppIdWorkflowCommentsByCommentIdResolvePath = z.object({
  app_id: z.uuid(),
  comment_id: z.string(),
})

/**
 * Comment resolved successfully
 */
export const zPostAppsByAppIdWorkflowCommentsByCommentIdResolveResponse = zWorkflowCommentResolve

export const zGetAppsByAppIdWorkflowStatisticsAverageAppInteractionsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowStatisticsAverageAppInteractionsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Average app interaction statistics retrieved successfully
 */
export const zGetAppsByAppIdWorkflowStatisticsAverageAppInteractionsResponse =
  zWorkflowAverageAppInteractionStatisticResponse

export const zGetAppsByAppIdWorkflowStatisticsDailyConversationsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowStatisticsDailyConversationsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily runs statistics retrieved successfully
 */
export const zGetAppsByAppIdWorkflowStatisticsDailyConversationsResponse =
  zWorkflowDailyRunsStatisticResponse

export const zGetAppsByAppIdWorkflowStatisticsDailyTerminalsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowStatisticsDailyTerminalsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily terminals statistics retrieved successfully
 */
export const zGetAppsByAppIdWorkflowStatisticsDailyTerminalsResponse =
  zWorkflowDailyTerminalsStatisticResponse

export const zGetAppsByAppIdWorkflowStatisticsTokenCostsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowStatisticsTokenCostsQuery = z.object({
  end: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Daily token cost statistics retrieved successfully
 */
export const zGetAppsByAppIdWorkflowStatisticsTokenCostsResponse =
  zWorkflowDailyTokenCostStatisticResponse

export const zGetAppsByAppIdWorkflowsPath = z.object({
  app_id: z.uuid(),
})

export const zGetAppsByAppIdWorkflowsQuery = z.object({
  limit: z.int().gte(1).lte(100).optional().default(10),
  named_only: z.boolean().optional().default(false),
  page: z.int().gte(1).lte(99999).optional().default(1),
  user_id: z.string().optional(),
})

/**
 * Published workflows retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsResponse = zWorkflowPaginationResponse

export const zGetAppsByAppIdWorkflowsDefaultWorkflowBlockConfigsPath = z.object({
  app_id: z.uuid(),
})

/**
 * Default block configurations retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDefaultWorkflowBlockConfigsResponse =
  zDefaultBlockConfigsResponse

export const zGetAppsByAppIdWorkflowsDefaultWorkflowBlockConfigsByBlockTypePath = z.object({
  app_id: z.uuid(),
  block_type: z.string(),
})

export const zGetAppsByAppIdWorkflowsDefaultWorkflowBlockConfigsByBlockTypeQuery = z.object({
  q: z.string().optional(),
})

/**
 * Default block configuration retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDefaultWorkflowBlockConfigsByBlockTypeResponse =
  zDefaultBlockConfigResponse

export const zGetAppsByAppIdWorkflowsDraftPath = z.object({
  app_id: z.uuid(),
})

/**
 * Draft workflow retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftResponse = zWorkflowResponse

export const zPostAppsByAppIdWorkflowsDraftBody = zSyncDraftWorkflowPayload

export const zPostAppsByAppIdWorkflowsDraftPath = z.object({
  app_id: z.uuid(),
})

/**
 * Draft workflow synced successfully
 */
export const zPostAppsByAppIdWorkflowsDraftResponse = zSyncDraftWorkflowResponse

export const zGetAppsByAppIdWorkflowsDraftConversationVariablesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Conversation variables retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftConversationVariablesResponse =
  zWorkflowDraftVariableListResponse

export const zPostAppsByAppIdWorkflowsDraftConversationVariablesBody =
  zConversationVariableUpdatePayload

export const zPostAppsByAppIdWorkflowsDraftConversationVariablesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Conversation variables updated successfully
 */
export const zPostAppsByAppIdWorkflowsDraftConversationVariablesResponse = zSimpleResultResponse

export const zGetAppsByAppIdWorkflowsDraftEnvironmentVariablesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Environment variables retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftEnvironmentVariablesResponse =
  zEnvironmentVariableListResponse

export const zPostAppsByAppIdWorkflowsDraftEnvironmentVariablesBody =
  zEnvironmentVariableUpdatePayload

export const zPostAppsByAppIdWorkflowsDraftEnvironmentVariablesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Environment variables updated successfully
 */
export const zPostAppsByAppIdWorkflowsDraftEnvironmentVariablesResponse = zSimpleResultResponse

export const zPostAppsByAppIdWorkflowsDraftFeaturesBody = zWorkflowFeaturesPayload

export const zPostAppsByAppIdWorkflowsDraftFeaturesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Workflow features updated successfully
 */
export const zPostAppsByAppIdWorkflowsDraftFeaturesResponse = zSimpleResultResponse

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdDeliveryTestBody =
  zHumanInputDeliveryTestPayload

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdDeliveryTestPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Human input delivery test result
 */
export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdDeliveryTestResponse =
  zEmptyObjectResponse

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdFormPreviewBody =
  zHumanInputFormPreviewPayload

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdFormPreviewPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Human input form preview
 */
export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdFormPreviewResponse =
  zHumanInputFormPreviewResponse

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdFormRunBody =
  zHumanInputFormPreviewSubmitPayload

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdFormRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Human input form submission result
 */
export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdFormRunResponse =
  zHumanInputFormSubmitResponse

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdMessageTemplateTestBody =
  zMessageTemplateTestRequest

export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdMessageTemplateTestPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
  })

/**
 * Success
 */
export const zPostAppsByAppIdWorkflowsDraftHumanInputNodesByNodeIdMessageTemplateTestResponse =
  zMessageTemplateTestResponse

export const zPostAppsByAppIdWorkflowsDraftIterationNodesByNodeIdRunBody = zIterationNodeRunPayload

export const zPostAppsByAppIdWorkflowsDraftIterationNodesByNodeIdRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow iteration node run started successfully
 */
export const zPostAppsByAppIdWorkflowsDraftIterationNodesByNodeIdRunResponse = zGeneratedAppResponse

export const zPostAppsByAppIdWorkflowsDraftLoopNodesByNodeIdRunBody = zLoopNodeRunPayload

export const zPostAppsByAppIdWorkflowsDraftLoopNodesByNodeIdRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow loop node run started successfully
 */
export const zPostAppsByAppIdWorkflowsDraftLoopNodesByNodeIdRunResponse = zGeneratedAppResponse

export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerQuery = z.object({
  snapshot_id: z.string().max(255).optional(),
})

/**
 * Workflow agent composer state
 */
export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerResponse =
  zWorkflowAgentComposerResponse

export const zPutAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerBody = zComposerSavePayload

export const zPutAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow agent composer saved
 */
export const zPutAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerResponse =
  zWorkflowAgentComposerResponse

export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerCandidatesPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow agent composer candidates
 */
export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerCandidatesResponse =
  zAgentComposerCandidatesResponse

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerCopyFromRosterBody =
  zWorkflowComposerCopyFromRosterPayload

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerCopyFromRosterPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow roster agent copied to inline agent
 */
export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerCopyFromRosterResponse =
  zWorkflowAgentComposerResponse

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerImpactBody =
  zComposerSavePayload

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerImpactPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow agent composer impact
 */
export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerImpactResponse =
  zAgentComposerImpactResponse

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerSaveToRosterBody =
  zComposerSavePayload

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerSaveToRosterPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow agent composer saved to roster
 */
export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerSaveToRosterResponse =
  zWorkflowAgentComposerResponse

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerValidateBody =
  zComposerSavePayload

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerValidatePath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Workflow agent composer validation result
 */
export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdAgentComposerValidateResponse =
  zAgentComposerValidateResponse

export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdLastRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Node last run retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdLastRunResponse =
  zWorkflowRunNodeExecutionResponse

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdRunBody = zDraftWorkflowNodeRunPayload

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Node run started successfully
 */
export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdRunResponse =
  zWorkflowRunNodeExecutionResponse

export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdTriggerRunPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Trigger event received and node executed successfully
 */
export const zPostAppsByAppIdWorkflowsDraftNodesByNodeIdTriggerRunResponse = zGeneratedAppResponse

export const zDeleteAppsByAppIdWorkflowsDraftNodesByNodeIdVariablesPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Node variables deleted successfully
 */
export const zDeleteAppsByAppIdWorkflowsDraftNodesByNodeIdVariablesResponse = z.void()

export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdVariablesPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
})

/**
 * Node variables retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftNodesByNodeIdVariablesResponse =
  zWorkflowDraftVariableListResponse

export const zPostAppsByAppIdWorkflowsDraftRunBody = zDraftWorkflowRunPayload

export const zPostAppsByAppIdWorkflowsDraftRunPath = z.object({
  app_id: z.uuid(),
})

/**
 * Draft workflow run started successfully
 */
export const zPostAppsByAppIdWorkflowsDraftRunResponse = zGeneratedAppResponse

export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsPath = z.object({
  app_id: z.uuid(),
  run_id: z.uuid(),
})

/**
 * Workflow run node outputs
 */
export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsResponse = zWorkflowRunSnapshotView

export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsEventsPath = z.object({
  app_id: z.uuid(),
  run_id: z.uuid(),
})

/**
 * Workflow run node output event stream
 */
export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsEventsResponse =
  zEventStreamResponse

export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsByNodeIdPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
  run_id: z.uuid(),
})

/**
 * Workflow run node output detail
 */
export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsByNodeIdResponse = zNodeOutputsView

export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsByNodeIdByOutputNamePreviewPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
    output_name: z.string(),
    run_id: z.uuid(),
  })

/**
 * Workflow run node output preview
 */
export const zGetAppsByAppIdWorkflowsDraftRunsByRunIdNodeOutputsByNodeIdByOutputNamePreviewResponse =
  zOutputPreviewView

export const zGetAppsByAppIdWorkflowsDraftSystemVariablesPath = z.object({
  app_id: z.uuid(),
})

/**
 * System variables retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftSystemVariablesResponse =
  zWorkflowDraftVariableListResponse

export const zPostAppsByAppIdWorkflowsDraftTriggerRunBody = zDraftWorkflowTriggerRunPayload

export const zPostAppsByAppIdWorkflowsDraftTriggerRunPath = z.object({
  app_id: z.uuid(),
})

/**
 * Trigger event received and workflow executed successfully
 */
export const zPostAppsByAppIdWorkflowsDraftTriggerRunResponse = zGeneratedAppResponse

export const zPostAppsByAppIdWorkflowsDraftTriggerRunAllBody = zDraftWorkflowTriggerRunAllPayload

export const zPostAppsByAppIdWorkflowsDraftTriggerRunAllPath = z.object({
  app_id: z.uuid(),
})

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

export const zDeleteAppsByAppIdWorkflowsDraftVariablesPath = z.object({
  app_id: z.uuid(),
})

/**
 * Workflow variables deleted successfully
 */
export const zDeleteAppsByAppIdWorkflowsDraftVariablesResponse = z.void()

export const zGetAppsByAppIdWorkflowsDraftVariablesPath = z.object({
  app_id: z.uuid(),
})

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

/**
 * Workflow variables retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftVariablesResponse =
  zWorkflowDraftVariableListWithoutValueResponse

export const zDeleteAppsByAppIdWorkflowsDraftVariablesByVariableIdPath = z.object({
  app_id: z.uuid(),
  variable_id: z.uuid(),
})

/**
 * Variable deleted successfully
 */
export const zDeleteAppsByAppIdWorkflowsDraftVariablesByVariableIdResponse = z.void()

export const zGetAppsByAppIdWorkflowsDraftVariablesByVariableIdPath = z.object({
  app_id: z.uuid(),
  variable_id: z.uuid(),
})

/**
 * Variable retrieved successfully
 */
export const zGetAppsByAppIdWorkflowsDraftVariablesByVariableIdResponse =
  zWorkflowDraftVariableResponse

export const zPatchAppsByAppIdWorkflowsDraftVariablesByVariableIdBody =
  zWorkflowDraftVariableUpdatePayload

export const zPatchAppsByAppIdWorkflowsDraftVariablesByVariableIdPath = z.object({
  app_id: z.uuid(),
  variable_id: z.uuid(),
})

/**
 * Variable updated successfully
 */
export const zPatchAppsByAppIdWorkflowsDraftVariablesByVariableIdResponse =
  zWorkflowDraftVariableResponse

export const zPutAppsByAppIdWorkflowsDraftVariablesByVariableIdResetPath = z.object({
  app_id: z.uuid(),
  variable_id: z.uuid(),
})

export const zPutAppsByAppIdWorkflowsDraftVariablesByVariableIdResetResponse = z.union([
  zWorkflowDraftVariableResponse,
  z.void(),
])

export const zGetAppsByAppIdWorkflowsPublishPath = z.object({
  app_id: z.uuid(),
})

/**
 * Published workflow retrieved successfully, or null if not found
 */
export const zGetAppsByAppIdWorkflowsPublishResponse = zWorkflowResponse

export const zPostAppsByAppIdWorkflowsPublishBody = zPublishWorkflowPayload

export const zPostAppsByAppIdWorkflowsPublishPath = z.object({
  app_id: z.uuid(),
})

/**
 * Workflow published successfully
 */
export const zPostAppsByAppIdWorkflowsPublishResponse = zWorkflowPublishResponse

export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsPath = z.object({
  app_id: z.uuid(),
  run_id: z.uuid(),
})

/**
 * Workflow run node outputs
 */
export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsResponse =
  zWorkflowRunSnapshotView

export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsEventsPath = z.object({
  app_id: z.uuid(),
  run_id: z.uuid(),
})

/**
 * Workflow run node output event stream
 */
export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsEventsResponse =
  zEventStreamResponse

export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsByNodeIdPath = z.object({
  app_id: z.uuid(),
  node_id: z.string(),
  run_id: z.uuid(),
})

/**
 * Workflow run node output detail
 */
export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsByNodeIdResponse =
  zNodeOutputsView

export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsByNodeIdByOutputNamePreviewPath =
  z.object({
    app_id: z.uuid(),
    node_id: z.string(),
    output_name: z.string(),
    run_id: z.uuid(),
  })

/**
 * Workflow run node output preview
 */
export const zGetAppsByAppIdWorkflowsPublishedRunsByRunIdNodeOutputsByNodeIdByOutputNamePreviewResponse =
  zOutputPreviewView

export const zGetAppsByAppIdWorkflowsTriggersWebhookPath = z.object({
  app_id: z.uuid(),
})

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

/**
 * Success
 */
export const zGetAppsByAppIdWorkflowsTriggersWebhookResponse = zWebhookTriggerResponse

export const zDeleteAppsByAppIdWorkflowsByWorkflowIdPath = z.object({
  app_id: z.uuid(),
  workflow_id: z.string(),
})

/**
 * Workflow deleted successfully
 */
export const zDeleteAppsByAppIdWorkflowsByWorkflowIdResponse = z.void()

export const zPatchAppsByAppIdWorkflowsByWorkflowIdBody = zWorkflowUpdatePayload

export const zPatchAppsByAppIdWorkflowsByWorkflowIdPath = z.object({
  app_id: z.uuid(),
  workflow_id: z.string(),
})

/**
 * Workflow updated successfully
 */
export const zPatchAppsByAppIdWorkflowsByWorkflowIdResponse = zWorkflowResponse

export const zPostAppsByAppIdWorkflowsByWorkflowIdRestorePath = z.object({
  app_id: z.uuid(),
  workflow_id: z.string(),
})

/**
 * Workflow restored successfully
 */
export const zPostAppsByAppIdWorkflowsByWorkflowIdRestoreResponse = zWorkflowRestoreResponse

export const zGetAppsByResourceIdApiKeysPath = z.object({
  resource_id: z.uuid(),
})

/**
 * API keys retrieved successfully
 */
export const zGetAppsByResourceIdApiKeysResponse = zApiKeyList

export const zPostAppsByResourceIdApiKeysPath = z.object({
  resource_id: z.uuid(),
})

/**
 * API key created successfully
 */
export const zPostAppsByResourceIdApiKeysResponse = zApiKeyItem

export const zDeleteAppsByResourceIdApiKeysByApiKeyIdPath = z.object({
  api_key_id: z.uuid(),
  resource_id: z.uuid(),
})

/**
 * API key deleted successfully
 */
export const zDeleteAppsByResourceIdApiKeysByApiKeyIdResponse = z.void()