@sanity/workflow-engine 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -847,6 +847,65 @@ declare const AuthoringFieldEntrySchema: v.UnionSchema<
   undefined
 >;
 
+export declare type AuthoringManualTarget = v.InferOutput<
+  typeof AuthoringManualTargetSchema
+>;
+
+declare const AuthoringManualTargetSchema: v.VariantSchema<
+  "type",
+  [
+    v.StrictObjectSchema<
+      {
+        readonly type: v.LiteralSchema<"url", undefined>;
+        readonly url: v.SchemaWithPipe<
+          readonly [
+            v.StringSchema<undefined>,
+            v.UrlAction<string, "must be a valid URL">,
+            v.CheckAction<string, "must be an http(s) URL">,
+          ]
+        >;
+      },
+      undefined
+    >,
+    v.StrictObjectSchema<
+      {
+        readonly type: v.LiteralSchema<"field", undefined>;
+        readonly field: v.UnionSchema<
+          [
+            v.SchemaWithPipe<
+              readonly [
+                v.StringSchema<undefined>,
+                v.MinLengthAction<string, 1, "must be a non-empty string">,
+              ]
+            >,
+            v.StrictObjectSchema<
+              {
+                readonly scope: v.OptionalSchema<
+                  v.PicklistSchema<
+                    readonly ["workflow", "stage", "task"],
+                    `Invalid option: expected one of ${string}`
+                  >,
+                  undefined
+                >;
+                readonly field: v.SchemaWithPipe<
+                  readonly [
+                    v.StringSchema<undefined>,
+                    v.MinLengthAction<string, 1, "must be a non-empty string">,
+                  ]
+                >;
+              },
+              undefined
+            >,
+          ],
+          undefined
+        >;
+      },
+      undefined
+    >,
+  ],
+  undefined
+>;
+
 export declare type AuthoringStage = v.InferOutput<typeof AuthoringStageSchema>;
 
 declare const AuthoringStageSchema: v.StrictObjectSchema<
@@ -871,6 +930,86 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
             >;
             title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * Advisory BPMN-aligned classification of this task by its executor (see
+             * {@link TASK_KINDS}). Optional and derived from the task's shape when
+             * omitted; declaring it lets deploy check the shape matches the lane.
+             * Changes no gating or resolution — a label for tooling, like `assignees`.
+             */
+            kind: v.OptionalSchema<
+              v.PicklistSchema<
+                readonly ["user", "service", "script", "manual", "receive"],
+                `Invalid option: expected one of ${string}`
+              >,
+              undefined
+            >;
+            /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
+             *  metadata; only valid on a manual task (deploy-checked). */
+            target: v.OptionalSchema<
+              v.VariantSchema<
+                "type",
+                [
+                  v.StrictObjectSchema<
+                    {
+                      readonly type: v.LiteralSchema<"url", undefined>;
+                      readonly url: v.SchemaWithPipe<
+                        readonly [
+                          v.StringSchema<undefined>,
+                          v.UrlAction<string, "must be a valid URL">,
+                          v.CheckAction<string, "must be an http(s) URL">,
+                        ]
+                      >;
+                    },
+                    undefined
+                  >,
+                  v.StrictObjectSchema<
+                    {
+                      readonly type: v.LiteralSchema<"field", undefined>;
+                      readonly field: v.UnionSchema<
+                        [
+                          v.SchemaWithPipe<
+                            readonly [
+                              v.StringSchema<undefined>,
+                              v.MinLengthAction<
+                                string,
+                                1,
+                                "must be a non-empty string"
+                              >,
+                            ]
+                          >,
+                          v.StrictObjectSchema<
+                            {
+                              readonly scope: v.OptionalSchema<
+                                v.PicklistSchema<
+                                  readonly ["workflow", "stage", "task"],
+                                  `Invalid option: expected one of ${string}`
+                                >,
+                                undefined
+                              >;
+                              readonly field: v.SchemaWithPipe<
+                                readonly [
+                                  v.StringSchema<undefined>,
+                                  v.MinLengthAction<
+                                    string,
+                                    1,
+                                    "must be a non-empty string"
+                                  >,
+                                ]
+                              >;
+                            },
+                            undefined
+                          >,
+                        ],
+                        undefined
+                      >;
+                    },
+                    undefined
+                  >,
+                ],
+                undefined
+              >,
+              undefined
+            >;
             activation: v.OptionalSchema<
               v.PicklistSchema<
                 readonly ["auto", "manual"],
@@ -2784,6 +2923,86 @@ declare const AuthoringTaskSchema: v.StrictObjectSchema<
     >;
     title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Advisory BPMN-aligned classification of this task by its executor (see
+     * {@link TASK_KINDS}). Optional and derived from the task's shape when
+     * omitted; declaring it lets deploy check the shape matches the lane.
+     * Changes no gating or resolution — a label for tooling, like `assignees`.
+     */
+    kind: v.OptionalSchema<
+      v.PicklistSchema<
+        readonly ["user", "service", "script", "manual", "receive"],
+        `Invalid option: expected one of ${string}`
+      >,
+      undefined
+    >;
+    /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
+     *  metadata; only valid on a manual task (deploy-checked). */
+    target: v.OptionalSchema<
+      v.VariantSchema<
+        "type",
+        [
+          v.StrictObjectSchema<
+            {
+              readonly type: v.LiteralSchema<"url", undefined>;
+              readonly url: v.SchemaWithPipe<
+                readonly [
+                  v.StringSchema<undefined>,
+                  v.UrlAction<string, "must be a valid URL">,
+                  v.CheckAction<string, "must be an http(s) URL">,
+                ]
+              >;
+            },
+            undefined
+          >,
+          v.StrictObjectSchema<
+            {
+              readonly type: v.LiteralSchema<"field", undefined>;
+              readonly field: v.UnionSchema<
+                [
+                  v.SchemaWithPipe<
+                    readonly [
+                      v.StringSchema<undefined>,
+                      v.MinLengthAction<
+                        string,
+                        1,
+                        "must be a non-empty string"
+                      >,
+                    ]
+                  >,
+                  v.StrictObjectSchema<
+                    {
+                      readonly scope: v.OptionalSchema<
+                        v.PicklistSchema<
+                          readonly ["workflow", "stage", "task"],
+                          `Invalid option: expected one of ${string}`
+                        >,
+                        undefined
+                      >;
+                      readonly field: v.SchemaWithPipe<
+                        readonly [
+                          v.StringSchema<undefined>,
+                          v.MinLengthAction<
+                            string,
+                            1,
+                            "must be a non-empty string"
+                          >,
+                        ]
+                      >;
+                    },
+                    undefined
+                  >,
+                ],
+                undefined
+              >;
+            },
+            undefined
+          >,
+        ],
+        undefined
+      >,
+      undefined
+    >;
     activation: v.OptionalSchema<
       v.PicklistSchema<
         readonly ["auto", "manual"],
@@ -4471,6 +4690,105 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                         v.StringSchema<undefined>,
                         undefined
                       >;
+                      /**
+                       * Advisory BPMN-aligned classification of this task by its executor (see
+                       * {@link TASK_KINDS}). Optional and derived from the task's shape when
+                       * omitted; declaring it lets deploy check the shape matches the lane.
+                       * Changes no gating or resolution — a label for tooling, like `assignees`.
+                       */
+                      kind: v.OptionalSchema<
+                        v.PicklistSchema<
+                          readonly [
+                            "user",
+                            "service",
+                            "script",
+                            "manual",
+                            "receive",
+                          ],
+                          `Invalid option: expected one of ${string}`
+                        >,
+                        undefined
+                      >;
+                      /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
+                       *  metadata; only valid on a manual task (deploy-checked). */
+                      target: v.OptionalSchema<
+                        v.VariantSchema<
+                          "type",
+                          [
+                            v.StrictObjectSchema<
+                              {
+                                readonly type: v.LiteralSchema<
+                                  "url",
+                                  undefined
+                                >;
+                                readonly url: v.SchemaWithPipe<
+                                  readonly [
+                                    v.StringSchema<undefined>,
+                                    v.UrlAction<string, "must be a valid URL">,
+                                    v.CheckAction<
+                                      string,
+                                      "must be an http(s) URL"
+                                    >,
+                                  ]
+                                >;
+                              },
+                              undefined
+                            >,
+                            v.StrictObjectSchema<
+                              {
+                                readonly type: v.LiteralSchema<
+                                  "field",
+                                  undefined
+                                >;
+                                readonly field: v.UnionSchema<
+                                  [
+                                    v.SchemaWithPipe<
+                                      readonly [
+                                        v.StringSchema<undefined>,
+                                        v.MinLengthAction<
+                                          string,
+                                          1,
+                                          "must be a non-empty string"
+                                        >,
+                                      ]
+                                    >,
+                                    v.StrictObjectSchema<
+                                      {
+                                        readonly scope: v.OptionalSchema<
+                                          v.PicklistSchema<
+                                            readonly [
+                                              "workflow",
+                                              "stage",
+                                              "task",
+                                            ],
+                                            `Invalid option: expected one of ${string}`
+                                          >,
+                                          undefined
+                                        >;
+                                        readonly field: v.SchemaWithPipe<
+                                          readonly [
+                                            v.StringSchema<undefined>,
+                                            v.MinLengthAction<
+                                              string,
+                                              1,
+                                              "must be a non-empty string"
+                                            >,
+                                          ]
+                                        >;
+                                      },
+                                      undefined
+                                    >,
+                                  ],
+                                  undefined
+                                >;
+                              },
+                              undefined
+                            >,
+                          ],
+                          undefined
+                        >,
+                        undefined
+                      >;
                       activation: v.OptionalSchema<
                         v.PicklistSchema<
                           readonly ["auto", "manual"],
@@ -6524,7 +6842,29 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                   name: string;
                   title?: string | undefined;
                   description?: string | undefined;
-                  activation?: "auto" | "manual" | undefined;
+                  kind?:
+                    | "user"
+                    | "service"
+                    | "script"
+                    | "manual"
+                    | "receive"
+                    | undefined;
+                  target?:
+                    | {
+                        type: "url";
+                        url: string;
+                      }
+                    | {
+                        type: "field";
+                        field:
+                          | string
+                          | {
+                              scope?: "workflow" | "stage" | "task" | undefined;
+                              field: string;
+                            };
+                      }
+                    | undefined;
+                  activation?: "manual" | "auto" | undefined;
                   filter?: string | undefined;
                   requirements?:
                     | {
@@ -7466,6 +7806,17 @@ export declare interface DeployTarget {
   workflowResource: WorkflowResource;
 }
 
+/**
+ * Classify a task from its shape, in precedence order: a task a person acts on
+ * (`actions`) is `user`; otherwise an automated effect step is `service`;
+ * otherwise a task that waits on a condition (`completeWhen` or a `subworkflows`
+ * fan-out) is `receive`; otherwise an inline machine step is `script`.
+ *
+ * Never returns `manual` — off-system work reads identically to a `user` or
+ * `receive` task by shape, so it is only ever an EXPLICIT {@link Task.kind}.
+ */
+export declare function deriveTaskKind(task: Task): TaskKind;
+
 /**
  * The slice of an instance + its {@link WorkflowEvaluation} the classifier
  * reads. Narrowed so callers (and tests) can craft an exact stuck permutation
@@ -7675,6 +8026,50 @@ export declare interface DrainEffectsResult {
   skipped: PendingEffect[];
 }
 
+/**
+ * Driver-kind labels — the actor glyph for "who fired this action", recorded
+ * on the `actionFired` history entry. Standalone for the same reason as
+ * {@link TASK_KIND_DISPLAY}.
+ */
+export declare const DRIVER_KIND_DISPLAY: {
+  person: {
+    title: string;
+    description: string;
+  };
+  agent: {
+    title: string;
+    description: string;
+  };
+  service: {
+    title: string;
+    description: string;
+  };
+  engine: {
+    title: string;
+    description: string;
+  };
+};
+
+export declare const DRIVER_KINDS: readonly [
+  "person",
+  "agent",
+  "service",
+  "engine",
+];
+
+export declare type DriverKind = (typeof DRIVER_KINDS)[number];
+
+/**
+ * Classify the actor that drove an action for the audit-trail glyph: a human is
+ * a `person`, an LLM is an `agent`, and a `system` actor is the `engine` itself
+ * ({@link isEngineActor}) or otherwise an external `service`.
+ *
+ * Advisory and only as trustworthy as the {@link Actor} it reads — actor
+ * identity is itself advisory in this engine (the lake/token is authoritative),
+ * so this is a best-effort glyph, never an authorization signal.
+ */
+export declare function driverKind(actor: Actor): DriverKind;
+
 export declare type Editable = v.InferOutput<typeof StoredEditableSchema>;
 
 /**
@@ -8850,6 +9245,12 @@ export declare type HistoryEntry =
       task: TaskName;
       action: ActionName;
       actor?: Actor;
+      /**
+       * What KIND of driver fired the action, derived from {@link actor} at
+       * fire time (see `../task-kind.ts`) — the audit-trail glyph's
+       * person/agent/service/engine axis. Absent when no actor was supplied.
+       */
+      driverKind?: DriverKind;
     }
   | {
       _key: string;
@@ -9069,6 +9470,10 @@ export declare interface LoadedDoc {
 
 export declare type LoggerFactory = (name: string) => EngineLogger;
 
+export declare type ManualTarget = v.InferOutput<
+  typeof StoredManualTargetSchema
+>;
+
 /**
  * Evaluate a grant's GROQ filter against a single document with the
  * supplied identity. Returns true iff the document survives the filter.
@@ -10123,6 +10528,47 @@ declare const StoredFieldRefSchema: v.StrictObjectSchema<
   undefined
 >;
 
+declare const StoredManualTargetSchema: v.VariantSchema<
+  "type",
+  [
+    v.StrictObjectSchema<
+      {
+        readonly type: v.LiteralSchema<"url", undefined>;
+        readonly url: v.SchemaWithPipe<
+          readonly [
+            v.StringSchema<undefined>,
+            v.UrlAction<string, "must be a valid URL">,
+            v.CheckAction<string, "must be an http(s) URL">,
+          ]
+        >;
+      },
+      undefined
+    >,
+    v.StrictObjectSchema<
+      {
+        readonly type: v.LiteralSchema<"field", undefined>;
+        readonly field: v.StrictObjectSchema<
+          {
+            readonly scope: v.PicklistSchema<
+              readonly ["workflow", "stage", "task"],
+              `Invalid option: expected one of ${string}`
+            >;
+            readonly field: v.SchemaWithPipe<
+              readonly [
+                v.StringSchema<undefined>,
+                v.MinLengthAction<string, 1, "must be a non-empty string">,
+              ]
+            >;
+          },
+          undefined
+        >;
+      },
+      undefined
+    >,
+  ],
+  undefined
+>;
+
 declare const StoredOpSchema: v.VariantSchema<
   "type",
   [
@@ -10278,6 +10724,68 @@ declare const StoredStageSchema: v.StrictObjectSchema<
             >;
             title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
             description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * Advisory BPMN-aligned classification of this task by its executor (see
+             * {@link TASK_KINDS}). Optional and derived from the task's shape when
+             * omitted; declaring it lets deploy check the shape matches the lane.
+             * Changes no gating or resolution — a label for tooling, like `assignees`.
+             */
+            kind: v.OptionalSchema<
+              v.PicklistSchema<
+                readonly ["user", "service", "script", "manual", "receive"],
+                `Invalid option: expected one of ${string}`
+              >,
+              undefined
+            >;
+            /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
+             *  metadata; only valid on a manual task (deploy-checked). */
+            target: v.OptionalSchema<
+              v.VariantSchema<
+                "type",
+                [
+                  v.StrictObjectSchema<
+                    {
+                      readonly type: v.LiteralSchema<"url", undefined>;
+                      readonly url: v.SchemaWithPipe<
+                        readonly [
+                          v.StringSchema<undefined>,
+                          v.UrlAction<string, "must be a valid URL">,
+                          v.CheckAction<string, "must be an http(s) URL">,
+                        ]
+                      >;
+                    },
+                    undefined
+                  >,
+                  v.StrictObjectSchema<
+                    {
+                      readonly type: v.LiteralSchema<"field", undefined>;
+                      readonly field: v.StrictObjectSchema<
+                        {
+                          readonly scope: v.PicklistSchema<
+                            readonly ["workflow", "stage", "task"],
+                            `Invalid option: expected one of ${string}`
+                          >;
+                          readonly field: v.SchemaWithPipe<
+                            readonly [
+                              v.StringSchema<undefined>,
+                              v.MinLengthAction<
+                                string,
+                                1,
+                                "must be a non-empty string"
+                              >,
+                            ]
+                          >;
+                        },
+                        undefined
+                      >;
+                    },
+                    undefined
+                  >,
+                ],
+                undefined
+              >,
+              undefined
+            >;
             activation: v.OptionalSchema<
               v.PicklistSchema<
                 readonly ["auto", "manual"],
@@ -11612,6 +12120,68 @@ declare const StoredTaskSchema: v.StrictObjectSchema<
     >;
     title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Advisory BPMN-aligned classification of this task by its executor (see
+     * {@link TASK_KINDS}). Optional and derived from the task's shape when
+     * omitted; declaring it lets deploy check the shape matches the lane.
+     * Changes no gating or resolution — a label for tooling, like `assignees`.
+     */
+    kind: v.OptionalSchema<
+      v.PicklistSchema<
+        readonly ["user", "service", "script", "manual", "receive"],
+        `Invalid option: expected one of ${string}`
+      >,
+      undefined
+    >;
+    /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
+     *  metadata; only valid on a manual task (deploy-checked). */
+    target: v.OptionalSchema<
+      v.VariantSchema<
+        "type",
+        [
+          v.StrictObjectSchema<
+            {
+              readonly type: v.LiteralSchema<"url", undefined>;
+              readonly url: v.SchemaWithPipe<
+                readonly [
+                  v.StringSchema<undefined>,
+                  v.UrlAction<string, "must be a valid URL">,
+                  v.CheckAction<string, "must be an http(s) URL">,
+                ]
+              >;
+            },
+            undefined
+          >,
+          v.StrictObjectSchema<
+            {
+              readonly type: v.LiteralSchema<"field", undefined>;
+              readonly field: v.StrictObjectSchema<
+                {
+                  readonly scope: v.PicklistSchema<
+                    readonly ["workflow", "stage", "task"],
+                    `Invalid option: expected one of ${string}`
+                  >;
+                  readonly field: v.SchemaWithPipe<
+                    readonly [
+                      v.StringSchema<undefined>,
+                      v.MinLengthAction<
+                        string,
+                        1,
+                        "must be a non-empty string"
+                      >,
+                    ]
+                  >;
+                },
+                undefined
+              >;
+            },
+            undefined
+          >,
+        ],
+        undefined
+      >,
+      undefined
+    >;
     activation: v.OptionalSchema<
       v.PicklistSchema<
         readonly ["auto", "manual"],
@@ -12873,6 +13443,43 @@ export declare function tagScopeFilter(): string;
 
 export declare type Task = v.InferOutput<typeof StoredTaskSchema>;
 
+/**
+ * Task-kind labels — the per-kind renderer's heading + tooltip. Kept OUT of
+ * the combined {@link DISPLAY} map: kinds are a classification axis a consumer
+ * looks up deliberately, not a `_type`, and `"service"` collides with the
+ * same-named {@link DRIVER_KIND_DISPLAY} key.
+ */
+export declare const TASK_KIND_DISPLAY: {
+  user: {
+    title: string;
+    description: string;
+  };
+  service: {
+    title: string;
+    description: string;
+  };
+  script: {
+    title: string;
+    description: string;
+  };
+  manual: {
+    title: string;
+    description: string;
+  };
+  receive: {
+    title: string;
+    description: string;
+  };
+};
+
+export declare const TASK_KINDS: readonly [
+  "user",
+  "service",
+  "script",
+  "manual",
+  "receive",
+];
+
 /**
  * Leaf enums — the const arrays (and their derived union types) that both
  * the authoring schema and the engine address by name.
@@ -12924,6 +13531,12 @@ export declare interface TaskEntry {
 export declare interface TaskEvaluation {
   task: Task;
   status: TaskStatus;
+  /**
+   * The task's effective {@link TaskKind} — the explicit {@link Task.kind}, or
+   * the shape-derived default when omitted. Advisory: a label so a consumer can
+   * render each task as what it is (decision / wait / effect / off-system).
+   */
+  kind: TaskKind;
   /** Whether this task is the current actor's responsibility right now. */
   pendingOnActor: boolean;
   /**
@@ -12936,6 +13549,12 @@ export declare interface TaskEvaluation {
   actions: ActionEvaluation[];
 }
 
+export declare type TaskKind = (typeof TASK_KINDS)[number];
+
+/** The effective kind of a task: the explicitly declared {@link Task.kind}, or
+ *  the shape-derived default when omitted. */
+export declare function taskKind(task: Task): TaskKind;
+
 export declare type TaskName = string;
 
 export declare type TaskStatus = (typeof TASK_STATUSES)[number];
@@ -13628,6 +14247,83 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                         v.StringSchema<undefined>,
                         undefined
                       >;
+                      /**
+                       * Advisory BPMN-aligned classification of this task by its executor (see
+                       * {@link TASK_KINDS}). Optional and derived from the task's shape when
+                       * omitted; declaring it lets deploy check the shape matches the lane.
+                       * Changes no gating or resolution — a label for tooling, like `assignees`.
+                       */
+                      kind: v.OptionalSchema<
+                        v.PicklistSchema<
+                          readonly [
+                            "user",
+                            "service",
+                            "script",
+                            "manual",
+                            "receive",
+                          ],
+                          `Invalid option: expected one of ${string}`
+                        >,
+                        undefined
+                      >;
+                      /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
+                       *  metadata; only valid on a manual task (deploy-checked). */
+                      target: v.OptionalSchema<
+                        v.VariantSchema<
+                          "type",
+                          [
+                            v.StrictObjectSchema<
+                              {
+                                readonly type: v.LiteralSchema<
+                                  "url",
+                                  undefined
+                                >;
+                                readonly url: v.SchemaWithPipe<
+                                  readonly [
+                                    v.StringSchema<undefined>,
+                                    v.UrlAction<string, "must be a valid URL">,
+                                    v.CheckAction<
+                                      string,
+                                      "must be an http(s) URL"
+                                    >,
+                                  ]
+                                >;
+                              },
+                              undefined
+                            >,
+                            v.StrictObjectSchema<
+                              {
+                                readonly type: v.LiteralSchema<
+                                  "field",
+                                  undefined
+                                >;
+                                readonly field: v.StrictObjectSchema<
+                                  {
+                                    readonly scope: v.PicklistSchema<
+                                      readonly ["workflow", "stage", "task"],
+                                      `Invalid option: expected one of ${string}`
+                                    >;
+                                    readonly field: v.SchemaWithPipe<
+                                      readonly [
+                                        v.StringSchema<undefined>,
+                                        v.MinLengthAction<
+                                          string,
+                                          1,
+                                          "must be a non-empty string"
+                                        >,
+                                      ]
+                                    >;
+                                  },
+                                  undefined
+                                >;
+                              },
+                              undefined
+                            >,
+                          ],
+                          undefined
+                        >,
+                        undefined
+                      >;
                       activation: v.OptionalSchema<
                         v.PicklistSchema<
                           readonly ["auto", "manual"],
@@ -15062,7 +15758,27 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                   name: string;
                   title?: string | undefined;
                   description?: string | undefined;
-                  activation?: "auto" | "manual" | undefined;
+                  kind?:
+                    | "user"
+                    | "service"
+                    | "script"
+                    | "manual"
+                    | "receive"
+                    | undefined;
+                  target?:
+                    | {
+                        type: "url";
+                        url: string;
+                      }
+                    | {
+                        type: "field";
+                        field: {
+                          scope: "workflow" | "stage" | "task";
+                          field: string;
+                        };
+                      }
+                    | undefined;
+                  activation?: "manual" | "auto" | undefined;
                   filter?: string | undefined;
                   requirements?:
                     | {