dify/packages/contracts/generated/enterprise-app-deploy/zod.gen.ts

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

import * as z from 'zod'

/**
 * Represents a dynamically typed value which can be either null, a number, a string, a boolean, a recursive struct value, or a list of values.
 */
export const zGoogleProtobufValue = z.unknown()

export const zEnvironmentStatus = z.enum([
  'ENVIRONMENT_STATUS_UNSPECIFIED',
  'ENVIRONMENT_STATUS_PENDING',
  'ENVIRONMENT_STATUS_READY',
  'ENVIRONMENT_STATUS_FAILED',
  'ENVIRONMENT_STATUS_DELETING',
])

export const zApplicationInteractionStatus = z.enum([
  'APPLICATION_INTERACTION_STATUS_UNSPECIFIED',
  'APPLICATION_INTERACTION_STATUS_RUNNING',
  'APPLICATION_INTERACTION_STATUS_SUCCEEDED',
  'APPLICATION_INTERACTION_STATUS_FAILED',
  'APPLICATION_INTERACTION_STATUS_PARTIAL_SUCCEEDED',
  'APPLICATION_INTERACTION_STATUS_STOPPED',
  'APPLICATION_INTERACTION_STATUS_PAUSED',
])

export const zApplicationInteractionSource = z.enum([
  'APPLICATION_INTERACTION_SOURCE_UNSPECIFIED',
  'APPLICATION_INTERACTION_SOURCE_WEB_APP',
  'APPLICATION_INTERACTION_SOURCE_SERVICE_API',
  'APPLICATION_INTERACTION_SOURCE_TRIGGER',
  'APPLICATION_INTERACTION_SOURCE_EXPLORE',
  'APPLICATION_INTERACTION_SOURCE_DEBUGGER',
  'APPLICATION_INTERACTION_SOURCE_VALIDATION',
  'APPLICATION_INTERACTION_SOURCE_OPENAPI',
])

export const zEnvironmentMode = z.enum([
  'ENVIRONMENT_MODE_UNSPECIFIED',
  'ENVIRONMENT_MODE_SHARED',
  'ENVIRONMENT_MODE_ISOLATED',
])

export const zPluginCategory = z.enum([
  'PLUGIN_CATEGORY_UNSPECIFIED',
  'PLUGIN_CATEGORY_MODEL',
  'PLUGIN_CATEGORY_TOOL',
])

export const zDeploymentOperationType = z.enum([
  'DEPLOYMENT_OPERATION_TYPE_UNSPECIFIED',
  'DEPLOYMENT_OPERATION_TYPE_DEPLOY',
  'DEPLOYMENT_OPERATION_TYPE_UNDEPLOY',
])

export const zDeploymentOperationOutcome = z.enum([
  'DEPLOYMENT_OPERATION_OUTCOME_UNSPECIFIED',
  'DEPLOYMENT_OPERATION_OUTCOME_IN_PROGRESS',
  'DEPLOYMENT_OPERATION_OUTCOME_SUCCEEDED',
  'DEPLOYMENT_OPERATION_OUTCOME_FAILED',
])

export const zDeploymentOperationFailureCode = z.enum([
  'DEPLOYMENT_OPERATION_FAILURE_CODE_UNSPECIFIED',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_DEPLOYMENT_IN_PROGRESS',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_NOTHING_TO_UNDEPLOY',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_DEPLOYMENT_STATE_CHANGED',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_APPLICATION_UNAVAILABLE',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_TARGET_ENVIRONMENT_UNAVAILABLE',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_TARGET_ENVIRONMENT_REMOVED',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_TARGET_ENVIRONMENT_INVALID',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_TARGET_ENVIRONMENT_ACCESS_DENIED',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_VERSION_UNAVAILABLE',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_VERSION_NOT_DEPLOYABLE',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_REQUIRED_CONFIGURATION_MISSING',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_DEPLOYMENT_CONFIGURATION_INVALID',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_CREDENTIAL_UNAVAILABLE',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_RUNTIME_UNAVAILABLE',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_DEPLOYMENT_TIMEOUT',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_DEPLOYMENT_INTERRUPTED',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_INTERNAL_ERROR',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_ENVIRONMENT_CPU_POOL_EXHAUSTED',
  'DEPLOYMENT_OPERATION_FAILURE_CODE_APP_RUNNER_ENV_CPU_LIMIT_EXCEEDED',
])

export const zDeploymentOperationStatus = z.enum([
  'DEPLOYMENT_OPERATION_STATUS_UNSPECIFIED',
  'DEPLOYMENT_OPERATION_STATUS_IN_PROGRESS',
  'DEPLOYMENT_OPERATION_STATUS_SUCCEEDED',
  'DEPLOYMENT_OPERATION_STATUS_FAILED',
])

export const zEnvironmentBackend = z.enum([
  'ENVIRONMENT_BACKEND_UNSPECIFIED',
  'ENVIRONMENT_BACKEND_KUBERNETES',
  'ENVIRONMENT_BACKEND_EXTERNAL',
])

export const zRuntimeState = z.enum([
  'RUNTIME_STATE_UNSPECIFIED',
  'RUNTIME_STATE_UNDEPLOYED',
  'RUNTIME_STATE_RUNNING',
  'RUNTIME_STATE_STARTING',
  'RUNTIME_STATE_STOPPING',
  'RUNTIME_STATE_ERROR',
  'RUNTIME_STATE_UNKNOWN',
])

export const zEnvVarValueSource = z.enum([
  'ENV_VAR_VALUE_SOURCE_UNSPECIFIED',
  'ENV_VAR_VALUE_SOURCE_CONFIGURED',
  'ENV_VAR_VALUE_SOURCE_LAST_DEPLOYED',
  'ENV_VAR_VALUE_SOURCE_CUSTOM',
])

export const zEnvVarValueType = z.enum([
  'ENV_VAR_VALUE_TYPE_UNSPECIFIED',
  'ENV_VAR_VALUE_TYPE_STRING',
  'ENV_VAR_VALUE_TYPE_NUMBER',
  'ENV_VAR_VALUE_TYPE_SECRET',
  'ENV_VAR_VALUE_TYPE_LLM',
])

export const zOperatorType = z.enum([
  'OPERATOR_TYPE_UNSPECIFIED',
  'OPERATOR_TYPE_END_USER',
  'OPERATOR_TYPE_ACCOUNT',
  'OPERATOR_TYPE_SERVICE_ACCOUNT',
  'OPERATOR_TYPE_SYSTEM',
  'OPERATOR_TYPE_DASHBOARD_ACCOUNT',
])

export const zRouteTargetKind = z.enum([
  'ROUTE_TARGET_KIND_UNSPECIFIED',
  'ROUTE_TARGET_KIND_K8S_SERVICE',
  'ROUTE_TARGET_KIND_DIRECT_UPSTREAM',
])

export const zAppEnvironment = z.object({
  id: z.string(),
  display_name: z.string(),
  description: z.string(),
  status: zEnvironmentStatus,
  in_use: z.boolean(),
})

export const zBatchGetSourceVersionDeploymentsRequest = z.object({
  appId: z.string().optional(),
  sourceVersionIds: z.array(z.string()).optional(),
})

export const zCheckAppDeletableRequest = z.object({
  appId: z.string().optional(),
})

export const zCheckAppDeletableResponse = z.object({
  deletable: z.boolean().optional(),
  reason: z.string().optional(),
})

export const zCheckSourceVersionDeletableRequest = z.object({
  appId: z.string().optional(),
  sourceVersionId: z.string().optional(),
})

export const zCheckSourceVersionDeletableResponse = z.object({
  deletable: z.boolean().optional(),
  reason: z.string().optional(),
})

export const zCreateDockerComposeBundleRequest = z.object({
  environmentId: z.string().optional(),
  dockerNetwork: z.string(),
})

export const zCreateEnvironmentRequest = z.object({
  displayName: z.string(),
  description: z.string().optional(),
  mode: zEnvironmentMode,
  cpuPoolMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  namespace: z.string().optional(),
  maxMemoryMib: z.string().optional(),
})

export const zCredentialCandidate = z.object({
  credential_id: z.string(),
  provider_id: z.string(),
  category: zPluginCategory,
  display_name: z.string(),
  from_enterprise: z.boolean(),
})

export const zCredentialSelectionInput = z.object({
  provider_id: z.string(),
  category: zPluginCategory,
  credential_id: z.string(),
})

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

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

export const zDeleteServiceApiConversationRequest = z.object({
  conversationId: z.string(),
  user: z.string(),
})

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

export const zDeploymentEnvironment = z.object({
  id: z.string(),
  display_name: z.string(),
  status: zEnvironmentStatus,
  description: z.string(),
})

export const zDeploymentOperationReceipt = z.object({
  id: z.string(),
  type: zDeploymentOperationType,
  status: zDeploymentOperationStatus,
})

export const zDeployWorkflowResponse = z.object({
  operation: zDeploymentOperationReceipt,
})

export const zDockerComposeBundle = z.object({
  filename: z.string(),
  archive: z.string(),
  composeYaml: z.string(),
  configYaml: z.string(),
})

export const zCreateDockerComposeBundleResponse = z.object({
  bundle: zDockerComposeBundle,
})

export const zEnvironmentApi = z.object({
  enabled: z.boolean(),
  base_url: z.string(),
  api_key_count: z
    .int()
    .min(0, { error: 'Invalid value: Expected uint32 to be >= 0' })
    .max(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }),
})

export const zEnvironmentApiUpdate = z.object({
  enabled: z.boolean(),
})

export const zEnvironmentAccess = z.object({
  enable_site: z.boolean(),
  enable_api: z.boolean(),
})

/**
 * EnvironmentActivity reports a numerator and a denominator rather than a rate,
 * so a caller can tell a healthy environment from one nothing has called.
 */
export const zEnvironmentActivity = z.object({
  environmentId: z.string(),
  invocationCount: z.string(),
  failedInvocationCount: z.string(),
  failedDeploymentCount: z.string(),
  deployedAppCount: z.string(),
})

export const zEnvironmentApiKey = z.object({
  id: z.string(),
  type: z.string(),
  token: z.string(),
  last_used_at: z.number().optional(),
  created_at: z.number(),
})

export const zEnvironmentDeployedAppAttempt = z.object({
  operationId: z.string(),
  type: zDeploymentOperationType,
  outcome: zDeploymentOperationOutcome,
  failureCode: zDeploymentOperationFailureCode.optional(),
  failureMessage: z.string().optional(),
  requestedAt: z.iso.datetime(),
  finalizedAt: z.iso.datetime().optional(),
})

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

export const zEnvironmentPoolUsage = z.object({
  occupiedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  appCount: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
})

export const zEnvironmentSite = z.object({
  enabled: z.boolean(),
  code: z.string(),
  app_base_url: z.string(),
  access_mode: z.string(),
})

export const zEnvironmentSiteUpdate = z.object({
  enabled: z.boolean(),
})

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

export const zEnvironmentVariableInput = z.object({
  key: z.string(),
  value_source: zEnvVarValueSource,
  value: zGoogleProtobufValue.optional(),
})

export const zEnvironmentVariableSlot = z.object({
  key: z.string(),
  value_type: zEnvVarValueType,
  description: z.string(),
  has_configured_value: z.boolean(),
  has_last_deployed_value: z.boolean(),
  configured_value: zGoogleProtobufValue.optional(),
  last_deployed_value: zGoogleProtobufValue.optional(),
})

export const zEnvironmentWebAppSubjectAccountData = z.object({
  id: z.string().optional(),
  name: z.string().optional(),
  email: z.string().optional(),
  avatar: z.string().optional(),
})

export const zEnvironmentWebAppSubjectGroupData = z.object({
  id: z.string().optional(),
  name: z.string().optional(),
  group_size: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
})

export const zEnvironmentWebAppSubject = z.object({
  subject_id: z.string().optional(),
  subject_type: z.string().optional(),
  account_data: zEnvironmentWebAppSubjectAccountData.optional(),
  group_data: zEnvironmentWebAppSubjectGroupData.optional(),
})

export const zEnvironmentWebAppAccessModeUpdate = z.object({
  access_mode: z.string(),
  subjects: z.array(zEnvironmentWebAppSubject).optional(),
})

export const zError = z.object({
  reason: z
    .enum([
      'APPDEPLOY_ERROR_REASON_UNSPECIFIED',
      'APPDEPLOY_INTERNAL',
      'APPDEPLOY_INVALID_ARGUMENT',
      'APPDEPLOY_INVALID_TENANT_ID',
      'APPDEPLOY_INVALID_APP_ID',
      'APPDEPLOY_INVALID_SOURCE_VERSION_ID',
      'APPDEPLOY_INVALID_ENVIRONMENT_ID',
      'APPDEPLOY_INVALID_REVISION_ID',
      'APPDEPLOY_INVALID_DEPLOYMENT_ID',
      'APPDEPLOY_INVALID_CREDENTIAL_ID',
      'APPDEPLOY_INVALID_SUBJECT_ID',
      'APPDEPLOY_INVALID_API_KEY_ID',
      'APPDEPLOY_INVALID_ACCOUNT',
      'APPDEPLOY_ENVIRONMENT_MODE_REQUIRED',
      'APPDEPLOY_ENVIRONMENT_BACKEND_REQUIRED',
      'APPDEPLOY_APP_LOG_TIME_RANGE_REQUIRED',
      'APPDEPLOY_APP_LOG_INVALID_TIME_RANGE',
      'APPDEPLOY_APP_LOG_INVALID_CURSOR',
      'APPDEPLOY_APP_LOG_CURSOR_FILTER_MISMATCH',
      'APPDEPLOY_UNSUPPORTED_NODE_TYPE',
      'APPDEPLOY_UNSUPPORTED_TOOL_PROVIDER_TYPE',
      'APPDEPLOY_TOOL_PROVIDER_TYPE_INVALID',
      'APPDEPLOY_TOOL_PROVIDER_NOT_INSTALLED',
      'APPDEPLOY_MODEL_PROVIDER_NOT_INSTALLED',
      'APPDEPLOY_MODEL_TYPE_UNSUPPORTED',
      'APPDEPLOY_CREDENTIAL_MISMATCH',
      'APPDEPLOY_APP_RUNNER_JOIN_TOKEN_REQUIRED',
      'APPDEPLOY_INVALID_WORKFLOW_ID',
      'APPDEPLOY_INVALID_DEPLOYMENT_VERSION_ID',
      'APPDEPLOY_DEVELOPER_API_URL_NOT_CONFIGURED',
      'APPDEPLOY_UNAUTHORIZED',
      'APPDEPLOY_FORBIDDEN',
      'APPDEPLOY_APP_RUNNER_AUTH_REQUIRED',
      'APPDEPLOY_APP_RUNNER_INVALID_JOIN_TOKEN',
      'APPDEPLOY_APP_RUNNER_INVALID_CONTROL_TOKEN',
      'APPDEPLOY_WEB_APP_ACCESS_DENIED',
      'APPDEPLOY_ENVIRONMENT_NOT_FOUND',
      'APPDEPLOY_DEPLOYMENT_NOT_FOUND',
      'APPDEPLOY_REVISION_NOT_FOUND',
      'APPDEPLOY_ROLLBACK_TARGET_NOT_FOUND',
      'APPDEPLOY_APP_NOT_FOUND',
      'APPDEPLOY_CREDENTIAL_NOT_FOUND',
      'APPDEPLOY_ENVIRONMENT_WEB_APP_SETTING_NOT_FOUND',
      'APPDEPLOY_ACCESS_SUBJECT_NOT_FOUND',
      'APPDEPLOY_API_KEY_NOT_FOUND',
      'APPDEPLOY_SOURCE_VERSION_NOT_FOUND',
      'APPDEPLOY_WORKSPACE_NOT_FOUND',
      'APPDEPLOY_APP_RUNNER_NOT_FOUND',
      'APPDEPLOY_WORKFLOW_NOT_FOUND',
      'APPDEPLOY_RUN_FILE_NOT_FOUND',
      'APPDEPLOY_APPLICATION_UNAVAILABLE',
      'APPDEPLOY_TARGET_ENVIRONMENT_REMOVED',
      'APPDEPLOY_VERSION_UNAVAILABLE',
      'APPDEPLOY_CONVERSATION_NOT_FOUND',
      'APPDEPLOY_CHAT_MESSAGE_NOT_FOUND',
      'APPDEPLOY_CONFLICT',
      'APPDEPLOY_DEPLOYMENT_IN_PROGRESS',
      'APPDEPLOY_ALREADY_UNDEPLOYED',
      'APPDEPLOY_REVISION_ALREADY_TERMINAL',
      'APPDEPLOY_NO_IN_FLIGHT_DEPLOYMENT',
      'APPDEPLOY_ENVIRONMENT_CONFLICT',
      'APPDEPLOY_ENVIRONMENT_BUSY',
      'APPDEPLOY_ENV_VAR_KEY_CONFLICT',
      'APPDEPLOY_APP_HAS_ACTIVE_DEPLOYMENTS',
      'APPDEPLOY_SOURCE_VERSION_IN_USE',
      'APPDEPLOY_NOTHING_TO_UNDEPLOY',
      'APPDEPLOY_DEPLOYMENT_STATE_CHANGED',
      'APPDEPLOY_ENVIRONMENT_HAS_ACTIVE_DEPLOYMENTS',
      'APPDEPLOY_ENVIRONMENT_NOT_READY',
      'APPDEPLOY_ENVIRONMENT_CAPACITY_EXCEEDED',
      'APPDEPLOY_APP_RUNNER_ENV_CPU_LIMIT_EXCEEDED',
      'APPDEPLOY_SOURCE_VERSION_NOT_DEPLOYABLE',
      'APPDEPLOY_CREDENTIAL_GONE',
      'APPDEPLOY_SLOT_UNSATISFIED',
      'APPDEPLOY_WORKSPACE_INACTIVE',
      'APPDEPLOY_ENVIRONMENT_BACKEND_UNAVAILABLE',
      'APPDEPLOY_APP_RUNNER_REGISTRATION_NOT_ALLOWED',
      'APPDEPLOY_WORKFLOW_NOT_DEPLOYABLE',
      'APPDEPLOY_API_KEY_LIMIT_EXCEEDED',
      'APPDEPLOY_ENVIRONMENT_NOT_FAILED',
      'APPDEPLOY_TARGET_ENVIRONMENT_UNAVAILABLE',
      'APPDEPLOY_TARGET_ENVIRONMENT_INVALID',
      'APPDEPLOY_TARGET_ENVIRONMENT_ACCESS_DENIED',
      'APPDEPLOY_VERSION_NOT_DEPLOYABLE',
      'APPDEPLOY_REQUIRED_CONFIGURATION_MISSING',
      'APPDEPLOY_DEPLOYMENT_CONFIGURATION_INVALID',
      'APPDEPLOY_CREDENTIAL_UNAVAILABLE',
      'APPDEPLOY_RUNTIME_UNAVAILABLE',
      'APPDEPLOY_DEPLOYMENT_TIMEOUT',
      'APPDEPLOY_DEPLOYMENT_INTERRUPTED',
      'APPDEPLOY_ENVIRONMENT_CPU_POOL_EXHAUSTED',
      'APPDEPLOY_RESOURCE_NOT_APPLICABLE_FOR_MODE',
      'APPDEPLOY_ENVIRONMENT_CPU_POOL_BELOW_ALLOCATED',
      'APPDEPLOY_CHAT_CONTEXT_TOO_LARGE',
      'APPDEPLOY_FILE_GRANT_UNAVAILABLE',
      'APPDEPLOY_APP_RUNNER_CONTROL_NOT_CONFIGURED',
      'APPDEPLOY_RUNTIME_ASSIGNMENT_FAILED',
      'APPDEPLOY_REVISION_TIMEOUT',
      'APPDEPLOY_INTERNAL_ERROR',
      'APPDEPLOY_RECEIPT_RETRY',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_AUTH_REJECTED',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_NAMESPACE_MISSING',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_INSUFFICIENT_RBAC',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_DECRYPT_FAILED',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_INVALID_K8S_CONFIG',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_RESOURCE_COLLISION',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_APPLY_FAILED',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_SIGNING_KEY_MISSING',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_CONTROL_ENDPOINT_INVALID',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_K8S_UNREACHABLE',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_APP_RUNNER_NOT_READY',
      'APPDEPLOY_ENVIRONMENT_BOOTSTRAP_SSAR_UNAVAILABLE',
    ])
    .optional(),
  message: z.string().optional(),
  phase: z.string().optional(),
  occurredAt: z.iso.datetime().optional(),
  detailCode: z.string().optional(),
})

export const zGetApplicationInteractionSummaryResponse = z.object({
  totalCount: z.string(),
  failedCount: z.string(),
  lookbackStart: z.iso.datetime(),
})

export const zGetEnvironmentActivityResponse = z.object({
  data: z.array(zEnvironmentActivity),
})

export const zGetEnvironmentCapabilitiesResponse = z.object({
  backend: zEnvironmentBackend,
  supportedModes: z.array(
    z.enum([
      'ENVIRONMENT_MODE_UNSPECIFIED',
      'ENVIRONMENT_MODE_SHARED',
      'ENVIRONMENT_MODE_ISOLATED',
    ]),
  ),
  namespaceRequired: z.boolean(),
})

export const zGetEnvironmentWebAppSubjectsResponse = z.object({
  subjects: z.array(zEnvironmentWebAppSubject),
})

export const zGetWebAppAccessModeResponse = z.object({
  accessMode: z.string().optional(),
})

export const zGetWebAppLoginStatusResponse = z.object({
  logged_in: z.boolean().optional(),
  app_logged_in: z.boolean().optional(),
})

export const zGetWebAppPermissionResponse = z.object({
  result: z.boolean().optional(),
})

export const zListAppEnvironmentsResponse = z.object({
  data: z.array(zAppEnvironment),
})

export const zListEnvironmentApiKeysResponse = z.object({
  data: z.array(zEnvironmentApiKey),
})

export const zListEnvironmentTriggersResponse = z.object({
  data: z.array(zEnvironmentTrigger),
})

export const zMintServiceApiFileGrantRequest = z.object({
  tenantId: z.string().optional(),
  appId: z.string().optional(),
  environmentId: z.string().optional(),
  user: z.string().optional(),
})

export const zMintServiceApiFileGrantResponse = z.object({
  grant: z.string().optional(),
  expiresAt: z.string().optional(),
})

export const zNamedRef = z.object({
  id: z.string(),
  displayName: z.string(),
})

export const zEnvironmentPoolShare = z.object({
  app: zNamedRef,
  isolatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
})

/**
 * EnvironmentPoolComposition names the largest few apps drawing on a pool and
 * sums the rest, because a bar with forty segments says less than one with five
 * and a remainder.
 */
export const zEnvironmentPoolComposition = z.object({
  topApps: z.array(zEnvironmentPoolShare).optional(),
  otherCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  otherAppCount: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
})

export const zOperationApp = z.object({
  id: z.string().optional(),
  workspaceId: z.string().optional(),
  displayName: z.string().optional(),
})

export const zOperator = z.object({
  type: zOperatorType,
  id: z.string(),
  display_name: z.string(),
})

export const zPrepareAppDeletionRequest = z.object({
  tenantId: z.string().optional(),
  appId: z.string().optional(),
})

export const zRenameServiceApiConversationRequest = z.object({
  conversationId: z.string(),
  user: z.string(),
  name: z.string().optional(),
  autoGenerate: z.boolean().optional(),
})

export const zRenameWebAppConversationRequest = z.object({
  appCode: z.string(),
  conversationId: z.string(),
  name: z.string().optional(),
  autoGenerate: z.boolean().optional(),
})

export const zResolveApiTokenRouteRequest = z.object({
  token: z.string().optional(),
})

export const zResolveApiTokenRouteResponse = z.object({
  environmentId: z.string().optional(),
  namespace: z.string().optional(),
  serviceName: z.string().optional(),
  servicePort: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  appId: z.string().optional(),
  tenantId: z.string().optional(),
  deploymentId: z.string().optional(),
  servingRevisionId: z.string().optional(),
  targetKind: zRouteTargetKind.optional(),
  directUpstream: z.string().optional(),
  assignmentGeneration: z.string().optional(),
  decision: z.string().optional(),
})

export const zResolveWebAppRouteRequest = z.object({
  appCode: z.string().optional(),
  passport: z.string().optional(),
})

export const zResolveWebAppRouteResponse = z.object({
  decision: z.string().optional(),
  environmentId: z.string().optional(),
  namespace: z.string().optional(),
  serviceName: z.string().optional(),
  servicePort: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  appId: z.string().optional(),
  tenantId: z.string().optional(),
  deploymentId: z.string().optional(),
  servingRevisionId: z.string().optional(),
  targetKind: zRouteTargetKind.optional(),
  directUpstream: z.string().optional(),
  assignmentGeneration: z.string().optional(),
  userId: z.string().optional(),
  userFrom: z.string().optional(),
  userAuthType: z.string().optional(),
  fileGrant: z.string().optional(),
  fileGrantExpiresAt: z.string().optional(),
})

export const zRetryEnvironmentBootstrapRequest = z.object({
  environmentId: z.string().optional(),
})

/**
 * RunnerMemory sizes one app-runner. max_mib is absent when the operator chose
 * nothing, in which case the runner gets effective_max_mib.
 */
export const zRunnerMemory = z.object({
  maxMib: z.string().optional(),
  effectiveMaxMib: z.string().readonly().optional(),
  minMib: z.string().readonly().optional(),
})

export const zEnvironment = z.object({
  id: z.string(),
  displayName: z.string(),
  description: z.string(),
  mode: zEnvironmentMode,
  backend: zEnvironmentBackend,
  status: zEnvironmentStatus,
  statusMessage: z.string(),
  lastError: zError.optional(),
  namespace: z.string().optional(),
  cpuPoolMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  createdAt: z.iso.datetime(),
  updatedAt: z.iso.datetime(),
  memory: zRunnerMemory.optional(),
  usage: zEnvironmentPoolUsage.optional(),
})

export const zCreateEnvironmentResponse = z.object({
  environment: zEnvironment,
})

export const zGetEnvironmentResponse = z.object({
  environment: zEnvironment,
  pool: zEnvironmentPoolComposition.optional(),
})

export const zRetryEnvironmentBootstrapResponse = z.object({
  environment: zEnvironment,
})

/**
 * RunnerSizing describes a runner an app owns outright, so it is present only
 * in an isolated environment; elsewhere the runner belongs to the environment.
 */
export const zRunnerSizing = z.object({
  isolatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  memory: zRunnerMemory,
})

/**
 * SimpleAccount mirrors the account shape Dify's console API returns, so a
 * client can render an account the same way whichever API it came from.
 */
export const zSimpleAccount = z.object({
  id: z.string(),
  name: z.string().optional(),
  email: z.string().optional(),
})

export const zSourceVersionDeploymentEnvironment = z.object({
  id: z.string().optional(),
  name: z.string().optional(),
})

export const zSourceVersionDeployment = z.object({
  sourceVersionId: z.string().optional(),
  environments: z.array(zSourceVersionDeploymentEnvironment).optional(),
})

export const zBatchGetSourceVersionDeploymentsResponse = z.object({
  items: z.array(zSourceVersionDeployment).optional(),
})

export const zTestConnectionRequest = z.object({
  environmentId: z.string().optional(),
})

export const zTestConnectionResponse = z.object({
  reachable: z.boolean().optional(),
  message: z.string().optional(),
})

export const zUndeployEnvironmentAppResponse = z.object({
  operationId: z.string(),
})

export const zUndeployWorkflowResponse = z.object({
  operation: zDeploymentOperationReceipt,
})

export const zUnsupportedNodeProvider = z.object({
  plugin_id: z.string(),
  provider_id: z.string(),
  provider_type: z.string(),
  provider_name: z.string(),
})

export const zUpdateEnvironmentDeployedAppResourcesRequest = z.object({
  environmentId: z.string(),
  deploymentId: z.string(),
  isolatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  maxMemoryMib: z.string().optional(),
})

export const zUpdateEnvironmentDeployedAppResourcesResponse = z.object({
  deploymentId: z.string(),
  isolatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  allocatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  poolCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  memory: zRunnerMemory,
})

export const zUpdateEnvironmentRequest = z.object({
  environmentId: z.string().optional(),
  displayName: z.string().optional(),
  description: z.string().optional(),
  cpuPoolMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  maxMemoryMib: z.string().optional(),
})

export const zUpdateEnvironmentResponse = z.object({
  environment: zEnvironment,
})

export const zUpdateServiceApiConversationVariableRequest = z.object({
  conversationId: z.string(),
  variableId: z.string(),
  user: z.string(),
  value: zGoogleProtobufValue,
})

export const zWorkflowEnvironmentVariableInputGroup = z.object({
  workflow_id: z.string(),
  environment_variables: z.array(zEnvironmentVariableInput),
})

export const zWorkflowDeploymentInput = z.object({
  environment_variable_groups: z.array(zWorkflowEnvironmentVariableInputGroup),
  credentials: z.array(zCredentialSelectionInput).optional(),
})

export const zWorkflowReference = z.object({
  app_id: z.string(),
  workflow_id: z.string(),
  name: z.string(),
  icon: z.string(),
  icon_background: z.string(),
  icon_type: z.string(),
  icon_url: z.string().optional(),
})

export const zWorkflowPath = z.object({
  workflows: z.array(zWorkflowReference),
})

export const zWorkflowAsToolDependency = z.object({
  paths: z.array(zWorkflowPath),
})

export const zCredentialSlot = z.object({
  provider_id: z.string(),
  category: zPluginCategory,
  candidates: z.array(zCredentialCandidate),
  last_deployed_credential_id: z.string().optional(),
  icon: z.string().optional(),
  icon_dark: z.string().optional(),
  workflow_as_tool_dependency: zWorkflowAsToolDependency.optional(),
})

export const zUnsupportedNode = z.object({
  id: z.string(),
  type: z.string(),
  title: z.string(),
  provider: zUnsupportedNodeProvider.optional(),
  workflow_as_tool_dependency: zWorkflowAsToolDependency.optional(),
})

export const zPrecheckWorkflowDeploymentResponse = z.object({
  unsupported_nodes: z.array(zUnsupportedNode),
})

export const zWorkflowAsToolSource = z.object({
  workflow: zWorkflowReference,
  paths: z.array(zWorkflowPath),
})

export const zEnvironmentVariableGroup = z.object({
  from_app: zWorkflowReference.optional(),
  from_workflow_as_tool: zWorkflowAsToolSource.optional(),
  environment_variable_slots: z.array(zEnvironmentVariableSlot),
})

export const zGetWorkflowDeploymentOptionsResponse = z.object({
  environment_variable_groups: z.array(zEnvironmentVariableGroup),
  credential_slots: z.array(zCredentialSlot),
})

export const zWorkflowVersion = z.object({
  version: z.string().optional(),
  marked_name: z.string().optional(),
  id: z.string(),
  marked_comment: z.string().optional(),
  version_number: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  created_at: z.number().optional(),
  created_by: zSimpleAccount.optional(),
  dsl_hash: z.string().optional(),
})

export const zApplicationInteraction = z.object({
  id: z.string(),
  timestamp: z.iso.datetime(),
  status: zApplicationInteractionStatus,
  durationSeconds: z.number(),
  totalTokens: z.string(),
  workspace: zNamedRef,
  environment: zNamedRef,
  app: zNamedRef,
  operator: zNamedRef.optional(),
  source: zApplicationInteractionSource,
  version: zWorkflowVersion.optional(),
  traceId: z.string().optional(),
  error: z.string().optional(),
})

export const zDeploymentOperation = z.object({
  id: z.string(),
  type: zDeploymentOperationType,
  outcome: zDeploymentOperationOutcome,
  workspace: zNamedRef,
  operator: zOperator,
  app: zNamedRef,
  environment: zNamedRef,
  version: zWorkflowVersion,
  failureCode: zDeploymentOperationFailureCode.optional(),
  failureMessage: z.string().optional(),
  requestedAt: z.iso.datetime(),
  finalizedAt: z.iso.datetime().optional(),
  durationMilliseconds: z.string().optional(),
})

export const zEnvironmentDeployedApp = z.object({
  deploymentId: z.string(),
  workspace: zNamedRef,
  app: zNamedRef,
  runtimeState: zRuntimeState,
  currentVersion: zWorkflowVersion.optional(),
  deployedAt: z.iso.datetime().optional(),
  deployedBy: zOperator.optional(),
  latestAttempt: zEnvironmentDeployedAppAttempt.optional(),
  sizing: zRunnerSizing.optional(),
  occupiesPool: z.boolean().optional(),
  recentInvocationCount: z.string().optional(),
  versionsBehind: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
})

export const zEnvironmentDeploymentOperation = z.object({
  id: z.string(),
  type: zDeploymentOperationType,
  status: zDeploymentOperationStatus,
  target_version: zWorkflowVersion.optional(),
  operator: zOperator,
  activity_at: z.number(),
})

export const zEnvironmentDeploymentState = z.object({
  runtimeState: zRuntimeState,
  current_version: zWorkflowVersion.optional(),
  versions_behind: z
    .int()
    .min(0, { error: 'Invalid value: Expected uint32 to be >= 0' })
    .max(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' })
    .optional(),
  deployed_at: z.number().optional(),
  deployed_by: zOperator.optional(),
  latest_operation: zEnvironmentDeploymentOperation.optional(),
})

export const zEnvironmentDeployment = z.object({
  environment: zDeploymentEnvironment,
  deployment: zEnvironmentDeploymentState.optional(),
  access: zEnvironmentAccess,
})

export const zGetEnvironmentDeploymentResponse = z.object({
  environment_deployment: zEnvironmentDeployment,
})

export const zListApplicationInteractionsResponse = z.object({
  data: z.array(zApplicationInteraction),
  nextPageToken: z.string().optional(),
  previousPageToken: z.string().optional(),
})

export const zListEnvironmentDeploymentsResponse = z.object({
  environment_deployments: z.array(zEnvironmentDeployment),
})

/**
 * Pagination ： Just for pagination by page
 */
export const zPagination = z.object({
  totalCount: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  perPage: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  currentPage: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
  totalPages: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
})

export const zListApplicationInteractionAppsResponse = z.object({
  data: z.array(zNamedRef),
  pagination: zPagination,
})

export const zListDeploymentOperationsResponse = z.object({
  data: z.array(zDeploymentOperation),
  pagination: zPagination,
})

export const zListEnvironmentDeployedAppsResponse = z.object({
  data: z.array(zEnvironmentDeployedApp),
  pagination: zPagination,
})

export const zListEnvironmentsResponse = z.object({
  data: z.array(zEnvironment),
  pagination: zPagination,
})

export const zListOperationAppsResponse = z.object({
  data: z.array(zOperationApp),
  pagination: zPagination,
})

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

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

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

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

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

/**
 * RunnerMemory sizes one app-runner. max_mib is absent when the operator chose
 * nothing, in which case the runner gets effective_max_mib.
 */
export const zRunnerMemoryWritable = z.object({
  maxMib: z.string().optional(),
})

export const zEnvironmentWritable = z.object({
  id: z.string(),
  displayName: z.string(),
  description: z.string(),
  mode: zEnvironmentMode,
  backend: zEnvironmentBackend,
  status: zEnvironmentStatus,
  statusMessage: z.string(),
  lastError: zError.optional(),
  namespace: z.string().optional(),
  cpuPoolMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  createdAt: z.iso.datetime(),
  updatedAt: z.iso.datetime(),
  memory: zRunnerMemoryWritable.optional(),
  usage: zEnvironmentPoolUsage.optional(),
})

export const zCreateEnvironmentResponseWritable = z.object({
  environment: zEnvironmentWritable,
})

export const zGetEnvironmentResponseWritable = z.object({
  environment: zEnvironmentWritable,
  pool: zEnvironmentPoolComposition.optional(),
})

export const zListEnvironmentsResponseWritable = z.object({
  data: z.array(zEnvironmentWritable),
  pagination: zPagination,
})

export const zRetryEnvironmentBootstrapResponseWritable = z.object({
  environment: zEnvironmentWritable,
})

/**
 * RunnerSizing describes a runner an app owns outright, so it is present only
 * in an isolated environment; elsewhere the runner belongs to the environment.
 */
export const zRunnerSizingWritable = z.object({
  isolatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  memory: zRunnerMemoryWritable,
})

export const zEnvironmentDeployedAppWritable = z.object({
  deploymentId: z.string(),
  workspace: zNamedRef,
  app: zNamedRef,
  runtimeState: zRuntimeState,
  currentVersion: zWorkflowVersion.optional(),
  deployedAt: z.iso.datetime().optional(),
  deployedBy: zOperator.optional(),
  latestAttempt: zEnvironmentDeployedAppAttempt.optional(),
  sizing: zRunnerSizingWritable.optional(),
  occupiesPool: z.boolean().optional(),
  recentInvocationCount: z.string().optional(),
  versionsBehind: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
    .optional(),
})

export const zListEnvironmentDeployedAppsResponseWritable = z.object({
  data: z.array(zEnvironmentDeployedAppWritable),
  pagination: zPagination,
})

export const zUpdateEnvironmentDeployedAppResourcesResponseWritable = z.object({
  deploymentId: z.string(),
  isolatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  allocatedCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  poolCpuMillicores: z
    .int()
    .min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' })
    .max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
  memory: zRunnerMemoryWritable,
})

export const zUpdateEnvironmentResponseWritable = z.object({
  environment: zEnvironmentWritable,
})

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

/**
 * OK
 */
export const zConsoleDeploymentServiceListAppEnvironmentsResponse = zListAppEnvironmentsResponse

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

/**
 * OK
 */
export const zConsoleAccessServiceGetEnvironmentApiResponse = zEnvironmentApi

export const zConsoleAccessServiceUpdateEnvironmentApiBody = zEnvironmentApiUpdate

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

/**
 * OK
 */
export const zConsoleAccessServiceUpdateEnvironmentApiResponse = zEnvironmentApi

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

/**
 * OK
 */
export const zConsoleAccessServiceListEnvironmentApiKeysResponse = zListEnvironmentApiKeysResponse

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

/**
 * OK
 */
export const zConsoleAccessServiceCreateEnvironmentApiKeyResponse = zEnvironmentApiKey

export const zConsoleAccessServiceDeleteEnvironmentApiKeyPath = z.object({
  app_id: z.string(),
  environment_id: z.string(),
  api_key_id: z.string(),
})

/**
 * OK
 */
export const zConsoleAccessServiceDeleteEnvironmentApiKeyResponse = zDeleteEnvironmentApiKeyResponse

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

/**
 * OK
 */
export const zConsoleAccessServiceGetEnvironmentMcpServerResponse = zEnvironmentMcpServer

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

/**
 * OK
 */
export const zConsoleAccessServiceGetEnvironmentSiteResponse = zEnvironmentSite

export const zConsoleAccessServiceUpdateEnvironmentSiteBody = zEnvironmentSiteUpdate

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

/**
 * OK
 */
export const zConsoleAccessServiceUpdateEnvironmentSiteResponse = zEnvironmentSite

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

/**
 * OK
 */
export const zConsoleAccessServiceResetEnvironmentSiteAccessTokenResponse = zEnvironmentSite

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

/**
 * OK
 */
export const zConsoleAccessServiceListEnvironmentTriggersResponse = zListEnvironmentTriggersResponse

export const zConsoleAccessServiceUpdateEnvironmentWebAppAccessModeBody =
  zEnvironmentWebAppAccessModeUpdate

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

/**
 * OK
 */
export const zConsoleAccessServiceUpdateEnvironmentWebAppAccessModeResponse = zEnvironmentSite

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

/**
 * OK
 */
export const zConsoleAccessServiceGetEnvironmentWebAppSubjectsResponse =
  zGetEnvironmentWebAppSubjectsResponse

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

/**
 * OK
 */
export const zConsoleDeploymentServiceListEnvironmentDeploymentsResponse =
  zListEnvironmentDeploymentsResponse

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

/**
 * OK
 */
export const zConsoleDeploymentServiceGetEnvironmentDeploymentResponse =
  zGetEnvironmentDeploymentResponse

export const zConsoleDeploymentServiceGetWorkflowDeploymentOptionsPath = z.object({
  app_id: z.string(),
  workflow_id: z.string(),
  environment_id: z.string(),
})

/**
 * OK
 */
export const zConsoleDeploymentServiceGetWorkflowDeploymentOptionsResponse =
  zGetWorkflowDeploymentOptionsResponse

export const zConsoleDeploymentServiceDeployWorkflowBody = zWorkflowDeploymentInput

export const zConsoleDeploymentServiceDeployWorkflowPath = z.object({
  app_id: z.string(),
  workflow_id: z.string(),
  environment_id: z.string(),
})

/**
 * OK
 */
export const zConsoleDeploymentServiceDeployWorkflowResponse = zDeployWorkflowResponse

export const zConsoleDeploymentServiceUndeployWorkflowPath = z.object({
  app_id: z.string(),
  workflow_id: z.string(),
  environment_id: z.string(),
})

/**
 * OK
 */
export const zConsoleDeploymentServiceUndeployWorkflowResponse = zUndeployWorkflowResponse

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

/**
 * OK
 */
export const zConsoleDeploymentServicePrecheckWorkflowDeploymentResponse =
  zPrecheckWorkflowDeploymentResponse