@prefecthq/prefect-ui-library 2.9.18 → 2.10.0

package/src/automations/types/actions.ts

@@ -0,0 +1,325 @@
+import { ServerStateType, isServerStateType } from '@/models/StateType'
+import { SchemaValues } from '@/schemas/types/schemaValues'
+import { Equals, Require } from '@/types/utilities'
+import { createTuple, isNullish, isRecord, isString } from '@/utilities'
+
+export const { values: automationActionTypes, isValue: isAutomationActionType } = createTuple([
+  'cancel-flow-run',
+  'suspend-flow-run',
+  'change-flow-run-state',
+  'run-deployment',
+  'pause-deployment',
+  'resume-deployment',
+  'pause-work-queue',
+  'resume-work-queue',
+  'pause-work-pool',
+  'resume-work-pool',
+  'pause-automation',
+  'resume-automation',
+  'send-notification',
+  'do-nothing',
+])
+
+export type AutomationActionType = typeof automationActionTypes[number]
+
+export const automationActionTypeLabels = {
+  'cancel-flow-run': 'Cancel a flow run',
+  'suspend-flow-run': 'Suspend a flow run',
+  'change-flow-run-state': 'Change flow run\'s state',
+  'run-deployment': 'Run a deployment',
+  'pause-deployment': 'Pause a deployment',
+  'resume-deployment': 'Resume a deployment',
+  'pause-work-queue': 'Pause a work queue',
+  'resume-work-queue': 'Resume a work queue',
+  'pause-work-pool': 'Pause a work pool',
+  'resume-work-pool': 'Resume a work pool',
+  'pause-automation': 'Pause an automation',
+  'resume-automation': 'Resume an automation',
+  'send-notification': 'Send a notification',
+  'do-nothing': 'Do nothing',
+} as const satisfies Record<AutomationActionType, string>
+
+/**
+ * Utility type for creating individual automation action types.
+ * Enforces `type` is of type `AutomationActionType`.
+ */
+export type AutomationActionWithType<
+  TType extends AutomationActionType,
+  TRest extends Record<string, unknown> = Record<never, never>
+> = { type: TType } & TRest
+
+function isAutomationActionTypeRecord<T extends AutomationActionType>(value: unknown, type: T): value is ({ type: T } & Record<string, unknown>) {
+  return isRecord(value) && 'type' in value && value.type === type
+}
+
+/*
+ * Cancel a flow run
+ */
+export type AutomationActionCancelFlowRun = AutomationActionWithType<'cancel-flow-run'>
+
+function isAutomationActionCancelFlowRun(value: unknown): value is AutomationActionCancelFlowRun {
+  return isAutomationActionTypeRecord(value, 'cancel-flow-run')
+}
+
+/*
+ * Suspend a flow run
+ */
+export type AutomationActionSuspendFlowRun = AutomationActionWithType<'suspend-flow-run'>
+
+function isAutomationActionSuspendFlowRun(value: unknown): value is AutomationActionSuspendFlowRun {
+  return isAutomationActionTypeRecord(value, 'suspend-flow-run')
+}
+
+/*
+ * Change a flow run's state
+ */
+export type AutomationActionChangeFlowRunState = AutomationActionWithType<'change-flow-run-state', {
+  name?: string | null,
+  state: ServerStateType,
+  message?: string | null,
+}>
+
+export function isAutomationActionChangeFlowRunState(value: unknown): value is AutomationActionChangeFlowRunState {
+  if (!isAutomationActionTypeRecord(value, 'change-flow-run-state')) {
+    return false
+  }
+
+  const isValidName = isString(value.name) || isNullish(value.name)
+  const isValidState = isServerStateType(value.state)
+  const isValidMessage = isString(value.message) || isNullish(value.message)
+
+  return isValidName && isValidState && isValidMessage
+}
+
+/*
+ * Run a deployment
+ */
+export type AutomationActionRunDeployment = AutomationActionWithType<'run-deployment', {
+  deploymentId?: string | null,
+  parameters: SchemaValues | null,
+  jobVariables?: Record<string, unknown>,
+}>
+
+export function isAutomationActionRunDeployment(value: unknown): value is AutomationActionRunDeployment {
+  if (!isAutomationActionTypeRecord(value, 'run-deployment')) {
+    return false
+  }
+
+  const isValidDeploymentId = isString(value.deploymentId) || isNullish(value.deploymentId)
+  const isValidParameters = isRecord(value.parameters) || isNullish(value.parameters)
+
+  return isValidDeploymentId && isValidParameters
+}
+
+/*
+ * Pause a deployment
+ */
+export type AutomationActionPauseDeployment = AutomationActionWithType<'pause-deployment', {
+  deploymentId?: string | null,
+}>
+
+export function isAutomationActionPauseDeployment(value: unknown): value is AutomationActionPauseDeployment {
+  if (!isAutomationActionTypeRecord(value, 'pause-deployment')) {
+    return false
+  }
+
+  const isValidDeploymentId = isString(value.deploymentId) || isNullish(value.deploymentId)
+
+  return isValidDeploymentId
+}
+
+/*
+ * Resume a deployment
+ */
+export type AutomationActionResumeDeployment = AutomationActionWithType<'resume-deployment', {
+  deploymentId?: string | null,
+}>
+
+export function isAutomationActionResumeDeployment(value: unknown): value is AutomationActionResumeDeployment {
+  if (!isAutomationActionTypeRecord(value, 'resume-deployment')) {
+    return false
+  }
+
+  const isValidDeploymentId = isString(value.deploymentId) || isNullish(value.deploymentId)
+
+  return isValidDeploymentId
+}
+/*
+ * Pause a work queue
+ */
+export type AutomationActionPauseWorkQueue = AutomationActionWithType<'pause-work-queue', {
+  workQueueId?: string | null,
+}>
+
+function isAutomationActionPauseWorkQueue(value: unknown): value is AutomationActionPauseWorkQueue {
+  if (!isAutomationActionTypeRecord(value, 'pause-work-queue')) {
+    return false
+  }
+
+  const isValidWorkQueueId = isString(value.workQueueId) || isNullish(value.workQueueId)
+
+  return isValidWorkQueueId
+}
+
+/*
+ * Resume a work queue
+ */
+export type AutomationActionResumeWorkQueue = AutomationActionWithType<'resume-work-queue', {
+  workQueueId?: string | null,
+}>
+
+function isAutomationActionResumeWorkQueue(value: unknown): value is AutomationActionResumeWorkQueue {
+  if (!isAutomationActionTypeRecord(value, 'resume-work-queue')) {
+    return false
+  }
+
+  const isValidWorkQueueId = isString(value.workQueueId) || isNullish(value.workQueueId)
+
+  return isValidWorkQueueId
+}
+
+/*
+ * Pause a work pool
+ */
+export type AutomationActionPauseWorkPool = AutomationActionWithType<'pause-work-pool', {
+  workPoolId?: string | null,
+}>
+
+function isAutomationActionPauseWorkPool(value: unknown): value is AutomationActionPauseWorkPool {
+  if (!isAutomationActionTypeRecord(value, 'pause-work-pool')) {
+    return false
+  }
+
+  const isValidWorkPoolId = isString(value.workPoolId) || isNullish(value.workPoolId)
+
+  return isValidWorkPoolId
+}
+
+/*
+ * Resume a work pool
+ */
+export type AutomationActionResumeWorkPool = AutomationActionWithType<'resume-work-pool', {
+  workPoolId?: string | null,
+}>
+
+function isAutomationActionResumeWorkPool(value: unknown): value is AutomationActionResumeWorkPool {
+  if (!isAutomationActionTypeRecord(value, 'resume-work-pool')) {
+    return false
+  }
+
+  const isValidWorkPoolId = isString(value.workPoolId) || isNullish(value.workPoolId)
+
+  return isValidWorkPoolId
+}
+
+/*
+ * Pause an automation
+ */
+export type AutomationActionPauseAutomation = AutomationActionWithType<'pause-automation', {
+  automationId?: string | null,
+}>
+
+function isAutomationActionPauseAutomation(value: unknown): value is AutomationActionPauseAutomation {
+  if (!isAutomationActionTypeRecord(value, 'pause-automation')) {
+    return false
+  }
+
+  const isValidAutomationId = isString(value.automationId) || isNullish(value.automationId)
+
+  return isValidAutomationId
+}
+
+/*
+ * Resume an automation
+ */
+export type AutomationActionResumeAutomation = AutomationActionWithType<'resume-automation', {
+  automationId?: string | null,
+}>
+
+function isAutomationActionResumeAutomation(value: unknown): value is AutomationActionResumeAutomation {
+  if (!isAutomationActionTypeRecord(value, 'resume-automation')) {
+    return false
+  }
+
+  const isValidAutomationId = isString(value.automationId) || isNullish(value.automationId)
+
+  return isValidAutomationId
+}
+
+/*
+ * Send a notification
+ */
+export type AutomationActionSendNotification = AutomationActionWithType<'send-notification', {
+  blockDocumentId: string,
+  subject: string,
+  body: string,
+}>
+
+function isAutomationActionSendNotification(value: unknown): value is AutomationActionSendNotification {
+  if (!isAutomationActionTypeRecord(value, 'send-notification')) {
+    return false
+  }
+
+  const isValidBlockDocumentId = isString(value.blockDocumentId) || isNullish(value.blockDocumentId)
+  const isValidSubject = isString(value.subject)
+  const isValidBody = isString(value.body)
+
+  return isValidBlockDocumentId && isValidSubject && isValidBody
+}
+
+/*
+ * Do nothing
+ */
+
+export type AutomationActionDoNothing = AutomationActionWithType<'do-nothing'>
+
+function isAutomationActionDoNothing(value: unknown): value is AutomationActionDoNothing {
+  return isAutomationActionTypeRecord(value, 'do-nothing')
+}
+
+export type AutomationAction =
+  | AutomationActionCancelFlowRun
+  | AutomationActionSuspendFlowRun
+  | AutomationActionChangeFlowRunState
+  | AutomationActionRunDeployment
+  | AutomationActionPauseDeployment
+  | AutomationActionResumeDeployment
+  | AutomationActionPauseWorkQueue
+  | AutomationActionResumeWorkQueue
+  | AutomationActionPauseWorkPool
+  | AutomationActionResumeWorkPool
+  | AutomationActionPauseAutomation
+  | AutomationActionResumeAutomation
+  | AutomationActionSendNotification
+  | AutomationActionDoNothing
+
+/*
+ * if this is giving you a type error you forgot to add a type for your action to the AutomationAction type
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+const automationActionHasAllActionTypes: Equals<AutomationAction['type'], AutomationActionType> = true
+
+export type AutomationActionFields<T extends AutomationAction> = Require<Partial<T>, 'type'>
+
+const actionTypeGuardMap = {
+  'cancel-flow-run': isAutomationActionCancelFlowRun,
+  'suspend-flow-run': isAutomationActionSuspendFlowRun,
+  'change-flow-run-state': isAutomationActionChangeFlowRunState,
+  'run-deployment': isAutomationActionRunDeployment,
+  'pause-deployment': isAutomationActionPauseDeployment,
+  'resume-deployment': isAutomationActionResumeDeployment,
+  'pause-work-queue': isAutomationActionPauseWorkQueue,
+  'resume-work-queue': isAutomationActionResumeWorkQueue,
+  'pause-work-pool': isAutomationActionPauseWorkPool,
+  'resume-work-pool': isAutomationActionResumeWorkPool,
+  'pause-automation': isAutomationActionPauseAutomation,
+  'resume-automation': isAutomationActionResumeAutomation,
+  'send-notification': isAutomationActionSendNotification,
+  'do-nothing': isAutomationActionDoNothing,
+} satisfies Record<AutomationActionType, (value: unknown) => boolean>
+
+export function isAutomationAction(value: unknown): value is AutomationAction {
+  const guards = Object.values(actionTypeGuardMap)
+
+  return guards.some(guard => guard(value))
+}

package/src/automations/types/api/actions.ts

@@ -0,0 +1,194 @@
+import { AutomationActionType, AutomationActionWithType, isAutomationActionType } from '@/automations/types/actions'
+import { ServerStateType } from '@/models/StateType'
+import { SchemaValues } from '@/schemas/types/schemaValues'
+import { Equals } from '@/types/utilities'
+import { isRecord } from '@/utilities'
+
+export type AutomationActionResponse =
+| AutomationActionCancelFlowRunResponse
+| AutomationActionSuspendFlowRunResponse
+| AutomationActionChangeFlowRunStateResponse
+| AutomationActionRunDeploymentResponse
+| AutomationActionPauseDeploymentResponse
+| AutomationActionResumeDeploymentResponse
+| AutomationActionPauseWorkQueueResponse
+| AutomationActionResumeWorkQueueResponse
+| AutomationActionPauseWorkPoolResponse
+| AutomationActionResumeWorkPoolResponse
+| AutomationActionPauseAutomationResponse
+| AutomationActionResumeAutomationResponse
+| AutomationActionSendNotificationResponse
+| AutomationActionDoNothingResponse
+
+export type AutomationActionRequest = AutomationActionResponse
+
+/*
+ * if this is giving you a type error you forgot to add a response type for your action to the AutomationActionResponse type
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+const automationActionResponseHasAllActionTypes: Equals<AutomationActionResponse['type'], AutomationActionType> = true
+
+export function isAutomationActionResponse(value: unknown): value is AutomationActionResponse {
+  return isRecord(value) && isAutomationActionType(value.type)
+}
+
+/*
+ * Cancel a flow run
+ */
+export type AutomationActionCancelFlowRunResponse = AutomationActionWithType<'cancel-flow-run'>
+
+/*
+ * Suspend a flow run
+ */
+export type AutomationActionSuspendFlowRunResponse = AutomationActionWithType<'suspend-flow-run'>
+
+/*
+ * Change a flow run's state
+ */
+export type AutomationActionChangeFlowRunStateResponse = AutomationActionWithType<'change-flow-run-state', {
+  name?: string | null,
+  state: ServerStateType,
+  message?: string | null,
+}>
+
+/*
+ * Run a deployment
+ */
+export type AutomationActionRunDeploymentSelectedResponse = {
+  source: 'selected',
+  deployment_id: string,
+  parameters: SchemaValues | null,
+  job_variables?: Record<string, unknown>,
+}
+
+export type AutomationActionRunDeploymentInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionRunDeploymentResponse = AutomationActionWithType<'run-deployment', AutomationActionRunDeploymentSelectedResponse | AutomationActionRunDeploymentInferredResponse>
+
+/*
+ * Pause a deployment
+ */
+export type AutomationActionPauseDeploymentSelectedResponse = {
+  source: 'selected',
+  deployment_id: string,
+}
+
+export type AutomationActionPauseDeploymentInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionPauseDeploymentResponse = AutomationActionWithType<'pause-deployment', AutomationActionPauseDeploymentSelectedResponse | AutomationActionPauseDeploymentInferredResponse>
+
+/*
+ * Resume a deployment
+ */
+export type AutomationActionResumeDeploymentSelectedResponse = {
+  source: 'selected',
+  deployment_id: string,
+}
+
+export type AutomationActionResumeDeploymentInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionResumeDeploymentResponse = AutomationActionWithType<'resume-deployment', AutomationActionResumeDeploymentSelectedResponse | AutomationActionResumeDeploymentInferredResponse>
+
+/*
+ * Pause a work queue
+ */
+export type AutomationActionPauseWorkQueueSelectedResponse = {
+  source: 'selected',
+  work_queue_id: string,
+}
+
+export type AutomationActionPauseWorkQueueInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionPauseWorkQueueResponse = AutomationActionWithType<'pause-work-queue', AutomationActionPauseWorkQueueSelectedResponse | AutomationActionPauseWorkQueueInferredResponse>
+
+/*
+ * Resume a work queue
+ */
+export type AutomationActionResumeWorkQueueSelectedResponse = {
+  source: 'selected',
+  work_queue_id: string,
+}
+
+export type AutomationActionResumeWorkQueueInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionResumeWorkQueueResponse = AutomationActionWithType<'resume-work-queue', AutomationActionResumeWorkQueueSelectedResponse | AutomationActionResumeWorkQueueInferredResponse>
+
+/*
+ * Pause a work pool
+ */
+export type AutomationActionPauseWorkPoolSelectedResponse = {
+  source: 'selected',
+  work_pool_id: string,
+}
+
+export type AutomationActionPauseWorkPoolInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionPauseWorkPoolResponse = AutomationActionWithType<'pause-work-pool', AutomationActionPauseWorkPoolSelectedResponse | AutomationActionPauseWorkPoolInferredResponse>
+
+/*
+ * Resume a work pool
+ */
+export type AutomationActionResumeWorkPoolSelectedResponse = {
+  source: 'selected',
+  work_pool_id: string,
+}
+
+export type AutomationActionResumeWorkPoolInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionResumeWorkPoolResponse = AutomationActionWithType<'resume-work-pool', AutomationActionResumeWorkPoolSelectedResponse | AutomationActionResumeWorkPoolInferredResponse>
+
+/*
+ * Pause an automation
+ */
+export type AutomationActionPauseAutomationSelectedResponse = {
+  source: 'selected',
+  automation_id: string,
+}
+
+export type AutomationActionPauseAutomationInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionPauseAutomationResponse = AutomationActionWithType<'pause-automation', AutomationActionPauseAutomationSelectedResponse | AutomationActionPauseAutomationInferredResponse>
+
+/*
+ * Resume an automation
+ */
+export type AutomationActionResumeAutomationSelectedResponse = {
+  source: 'selected',
+  automation_id: string,
+}
+
+export type AutomationActionResumeAutomationInferredResponse = {
+  source: 'inferred',
+}
+
+export type AutomationActionResumeAutomationResponse = AutomationActionWithType<'resume-automation', AutomationActionResumeAutomationSelectedResponse | AutomationActionResumeAutomationInferredResponse>
+
+/*
+ * Send a notification
+ */
+export type AutomationActionSendNotificationResponse = AutomationActionWithType<'send-notification', {
+  block_document_id: string,
+  subject: string,
+  body: string,
+}>
+
+/**
+ * Do nothing
+ */
+export type AutomationActionDoNothingResponse = AutomationActionWithType<'do-nothing'>

package/src/automations/types/api/automation.ts

@@ -0,0 +1,6 @@
+export type AutomationResponse = {
+  id: string,
+  name: string,
+  description: string,
+  enabled: boolean,
+}

package/src/automations/types/api/triggers.ts

@@ -0,0 +1,54 @@
+import { isRecord } from '@/utilities/object'
+import { createTuple } from '@/utilities/tuples'
+
+export type AutomationTriggerEventResourceLabel =
+ | 'prefect.resource.id'
+ | 'prefect.resource.role'
+ | 'prefect.resource.name'
+ | 'prefect-cloud.incident.severity'
+
+export type AutomationTriggerEventResource =
+ | 'prefect.deployment'
+ | 'prefect.flow-run'
+ | 'prefect.flow'
+ | 'prefect.tag'
+ | 'prefect.work-pool'
+ | 'prefect.work-queue'
+ | 'prefect-cloud.incident'
+
+export type AutomationTriggerEventResourceRole =
+ | 'flow'
+ | 'tag'
+ | 'work-queue'
+ | 'work-pool'
+
+export type EventResourceValue = string | string[] | undefined
+
+export type AutomationTriggerMatch = Partial<Record<AutomationTriggerEventResourceLabel, EventResourceValue>>
+
+export const { values: automationTriggerEventPosture, isValue: isAutomationTriggerEventPosture } = createTuple([
+  'Reactive',
+  'Proactive',
+])
+
+export const DEFAULT_EVENT_TRIGGER_WITHIN = 0
+
+export type AutomationTriggerEventPosture = typeof automationTriggerEventPosture[number]
+
+export type AutomationTriggerEventResponse = {
+  type: 'event',
+  match?: AutomationTriggerMatch,
+  match_related?: AutomationTriggerMatch,
+  after?: string[],
+  expect?: string[],
+  for_each?: string[],
+  posture: AutomationTriggerEventPosture,
+  threshold: number,
+  within?: number,
+}
+
+export function isAutomationTriggerEventResponse(value: unknown): value is AutomationTriggerEventResponse {
+  return isRecord(value) && value.type === 'event' && isAutomationTriggerEventPosture(value.posture)
+}
+
+export type AutomationTriggerResponse = AutomationTriggerEventResponse

package/src/automations/types/automation.ts

@@ -0,0 +1,20 @@
+export interface IAutomation {
+  id: string,
+  name: string,
+  description: string,
+  enabled: boolean,
+}
+
+export class Automation {
+  public id: string
+  public name: string
+  public description: string
+  public enabled: boolean
+
+  public constructor(automation: IAutomation) {
+    this.id = automation.id
+    this.name = automation.name
+    this.description = automation.description
+    this.enabled = automation.enabled
+  }
+}

package/src/automations/types/automationTriggerEvent.ts

@@ -0,0 +1,47 @@
+import { AutomationTriggerMatch } from '@/automations/types/api/triggers'
+import { Require } from '@/types/utilities'
+import { createTuple } from '@/utilities/tuples'
+
+export const { values: automationTriggerEventPosture, isValue: isAutomationTriggerEventPosture } = createTuple([
+  'Reactive',
+  'Proactive',
+])
+
+export const DEFAULT_EVENT_TRIGGER_WITHIN = 0
+export const DEFAULT_EVENT_TRIGGER_THRESHOLD = 1
+
+export type AutomationTriggerEventPosture = typeof automationTriggerEventPosture[number]
+
+export type IAutomationTriggerEvent = {
+  posture: AutomationTriggerEventPosture,
+  match: AutomationTriggerMatch,
+  matchRelated: AutomationTriggerMatch,
+  forEach: string[],
+  after: string[],
+  expect: string[],
+  threshold: number,
+  within?: number | undefined,
+}
+
+export class AutomationTriggerEvent implements IAutomationTriggerEvent {
+  public readonly type = 'event'
+  public posture: AutomationTriggerEventPosture
+  public match: AutomationTriggerMatch
+  public matchRelated: AutomationTriggerMatch
+  public forEach: string[]
+  public after: string[]
+  public expect: string[]
+  public threshold: number
+  public within: number
+
+  public constructor(trigger: Require<Partial<IAutomationTriggerEvent>, 'posture'>) {
+    this.posture = trigger.posture
+    this.match = trigger.match ?? {}
+    this.matchRelated = trigger.matchRelated ?? {}
+    this.forEach = trigger.forEach ?? []
+    this.after = trigger.after ?? []
+    this.expect = trigger.expect ?? []
+    this.threshold = trigger.threshold ?? DEFAULT_EVENT_TRIGGER_THRESHOLD
+    this.within = trigger.within ?? DEFAULT_EVENT_TRIGGER_WITHIN
+  }
+}

package/src/automations/types/createAutomationQuery.ts

@@ -0,0 +1,50 @@
+import { isArray } from '@prefecthq/prefect-design'
+import { AutomationAction, isAutomationAction } from '@/automations/types/actions'
+import { isRecord } from '@/utilities/object'
+
+export type CreateEventAutomationQuery = {
+  from: 'event',
+  event: { id: string, occurred: Date },
+}
+
+export function isCreateEventAutomationQuery(value: unknown): value is CreateEventAutomationQuery {
+  return isRecord(value) && 'from' in value && value.from === 'event'
+}
+
+export type CreateFlowAutomationQuery = {
+  from: 'flow',
+  flowId: string,
+}
+
+export function isCreateFlowAutomationQuery(value: unknown): value is CreateFlowAutomationQuery {
+  return isRecord(value) && 'from' in value && value.from === 'flow'
+}
+
+export type CreateWorkPoolQueueAutomationQuery = {
+  from: 'workPoolQueue',
+  workPoolQueueId: string,
+}
+
+export function isCreateWorkPoolQueueAutomationQuery(value: unknown): value is CreateWorkPoolQueueAutomationQuery {
+  return isRecord(value) && 'from' in value && value.from === 'workPoolQueue'
+}
+
+export type CreateAutomationTriggerQuery =
+  | CreateEventAutomationQuery
+  | CreateFlowAutomationQuery
+  | CreateWorkPoolQueueAutomationQuery
+
+export function isCreateAutomationTriggerQuery(value: unknown): value is CreateAutomationTriggerQuery {
+  return isCreateEventAutomationQuery(value) || isCreateFlowAutomationQuery(value) || isCreateWorkPoolQueueAutomationQuery(value)
+}
+
+export type CreateAutomationActionQuery = { actions: AutomationAction[] }
+
+export function isCreateAutomationActionQuery(value: unknown): value is CreateAutomationActionQuery {
+  return isRecord(value) && 'actions' in value && isArray(value.actions) && value.actions.every(isAutomationAction)
+}
+
+export type CreateAutomationQuery =
+  | CreateAutomationTriggerQuery
+  | CreateAutomationActionQuery
+  | CreateAutomationTriggerQuery & CreateAutomationActionQuery