@sanity/workflow-engine 0.6.0 → 0.8.0

package/dist/define.d.cts

@@ -808,6 +808,33 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
               >,
               undefined
             >;
+            /**
+             * Readiness gates, by name — conditions over the rendered scope that must
+             * hold for the task to be *executable*, orthogonal to `filter`
+             * (visibility). An unmet requirement keeps the task visible but disables
+             * its actions with a `requirements-unmet` verdict naming the unmet keys;
+             * all must hold (any-of lives inside one condition). Advisory like every
+             * engine gate — the lake still enforces. Distinct from ACL (authorization)
+             * and guards (content-write locks).
+             */
+            requirements: v.OptionalSchema<
+              v.RecordSchema<
+                v.SchemaWithPipe<
+                  readonly [
+                    v.StringSchema<undefined>,
+                    v.MinLengthAction<string, 1, "must be a non-empty string">,
+                  ]
+                >,
+                v.SchemaWithPipe<
+                  readonly [
+                    v.StringSchema<undefined>,
+                    v.MinLengthAction<string, 1, "must be a non-empty string">,
+                  ]
+                >,
+                undefined
+              >,
+              undefined
+            >;
             /**
              * Auto-completion condition — evaluated at activation and on every
              * cascade; truthy flips the task to `done` with a system actor. On a
@@ -1960,6 +1987,17 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
                           v.StringSchema<undefined>,
                           undefined
                         >;
+                        /**
+                         * When true, the caller MUST supply this entry at start (via
+                         * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                         * missing required entry throws rather than silently defaulting to
+                         * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                         * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                         */
+                        readonly required: v.OptionalSchema<
+                          v.BooleanSchema<undefined>,
+                          undefined
+                        >;
                         readonly source: v.GenericSchema<SourceInternal>;
                       },
                       undefined
@@ -2509,6 +2547,17 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
                   v.StringSchema<undefined>,
                   undefined
                 >;
+                /**
+                 * When true, the caller MUST supply this entry at start (via
+                 * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                 * missing required entry throws rather than silently defaulting to
+                 * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                 * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                 */
+                readonly required: v.OptionalSchema<
+                  v.BooleanSchema<undefined>,
+                  undefined
+                >;
                 readonly source: v.GenericSchema<SourceInternal>;
               },
               undefined
@@ -2578,6 +2627,17 @@ declare const AuthoringStateEntrySchema: v.UnionSchema<
           v.StringSchema<undefined>,
           undefined
         >;
+        /**
+         * When true, the caller MUST supply this entry at start (via
+         * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+         * missing required entry throws rather than silently defaulting to
+         * `null`/`[]` — the same fail-fast an action's `required` param gets.
+         * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+         */
+        readonly required: v.OptionalSchema<
+          v.BooleanSchema<undefined>,
+          undefined
+        >;
         readonly source: v.GenericSchema<SourceInternal>;
       },
       undefined
@@ -2628,6 +2688,33 @@ declare const AuthoringTaskSchema: v.StrictObjectSchema<
       >,
       undefined
     >;
+    /**
+     * Readiness gates, by name — conditions over the rendered scope that must
+     * hold for the task to be *executable*, orthogonal to `filter`
+     * (visibility). An unmet requirement keeps the task visible but disables
+     * its actions with a `requirements-unmet` verdict naming the unmet keys;
+     * all must hold (any-of lives inside one condition). Advisory like every
+     * engine gate — the lake still enforces. Distinct from ACL (authorization)
+     * and guards (content-write locks).
+     */
+    requirements: v.OptionalSchema<
+      v.RecordSchema<
+        v.SchemaWithPipe<
+          readonly [
+            v.StringSchema<undefined>,
+            v.MinLengthAction<string, 1, "must be a non-empty string">,
+          ]
+        >,
+        v.SchemaWithPipe<
+          readonly [
+            v.StringSchema<undefined>,
+            v.MinLengthAction<string, 1, "must be a non-empty string">,
+          ]
+        >,
+        undefined
+      >,
+      undefined
+    >;
     /**
      * Auto-completion condition — evaluated at activation and on every
      * cascade; truthy flips the task to `done` with a system actor. On a
@@ -3695,6 +3782,17 @@ declare const AuthoringTaskSchema: v.StrictObjectSchema<
                   v.StringSchema<undefined>,
                   undefined
                 >;
+                /**
+                 * When true, the caller MUST supply this entry at start (via
+                 * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                 * missing required entry throws rather than silently defaulting to
+                 * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                 * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                 */
+                readonly required: v.OptionalSchema<
+                  v.BooleanSchema<undefined>,
+                  undefined
+                >;
                 readonly source: v.GenericSchema<SourceInternal>;
               },
               undefined
@@ -4057,6 +4155,22 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
       ]
     >;
     description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Whether a human may start this workflow standalone. `'child'` marks a
+     * spawn-only definition — instantiated by a parent via `task.subworkflows`,
+     * never started cold from a picker. Omitted ⇒ `'workflow'` (startable).
+     * Advisory: consumers filter their start pickers on it (see
+     * {@link isStartableDefinition}); the engine does NOT refuse a
+     * `startInstance` on a `'child'` def — load-bearing `required` state is the
+     * runtime backstop.
+     */
+    role: v.OptionalSchema<
+      v.PicklistSchema<
+        readonly ["workflow", "child"],
+        `Invalid option: expected one of ${string}`
+      >,
+      undefined
+    >;
     /** Reference field: named for the target, holds the stage's `name`. */
     initialStage: v.SchemaWithPipe<
       readonly [
@@ -4103,6 +4217,17 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                   v.StringSchema<undefined>,
                   undefined
                 >;
+                /**
+                 * When true, the caller MUST supply this entry at start (via
+                 * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                 * missing required entry throws rather than silently defaulting to
+                 * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                 * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                 */
+                readonly required: v.OptionalSchema<
+                  v.BooleanSchema<undefined>,
+                  undefined
+                >;
                 readonly source: v.GenericSchema<SourceInternal>;
               },
               undefined
@@ -4192,6 +4317,41 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                         >,
                         undefined
                       >;
+                      /**
+                       * Readiness gates, by name — conditions over the rendered scope that must
+                       * hold for the task to be *executable*, orthogonal to `filter`
+                       * (visibility). An unmet requirement keeps the task visible but disables
+                       * its actions with a `requirements-unmet` verdict naming the unmet keys;
+                       * all must hold (any-of lives inside one condition). Advisory like every
+                       * engine gate — the lake still enforces. Distinct from ACL (authorization)
+                       * and guards (content-write locks).
+                       */
+                      requirements: v.OptionalSchema<
+                        v.RecordSchema<
+                          v.SchemaWithPipe<
+                            readonly [
+                              v.StringSchema<undefined>,
+                              v.MinLengthAction<
+                                string,
+                                1,
+                                "must be a non-empty string"
+                              >,
+                            ]
+                          >,
+                          v.SchemaWithPipe<
+                            readonly [
+                              v.StringSchema<undefined>,
+                              v.MinLengthAction<
+                                string,
+                                1,
+                                "must be a non-empty string"
+                              >,
+                            ]
+                          >,
+                          undefined
+                        >,
+                        undefined
+                      >;
                       /**
                        * Auto-completion condition — evaluated at activation and on every
                        * cascade; truthy flips the task to `done` with a system actor. On a
@@ -5396,6 +5556,17 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                                     v.StringSchema<undefined>,
                                     undefined
                                   >;
+                                  /**
+                                   * When true, the caller MUST supply this entry at start (via
+                                   * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                                   * missing required entry throws rather than silently defaulting to
+                                   * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                                   * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                                   */
+                                  readonly required: v.OptionalSchema<
+                                    v.BooleanSchema<undefined>,
+                                    undefined
+                                  >;
                                   readonly source: v.GenericSchema<SourceInternal>;
                                 },
                                 undefined
@@ -6008,6 +6179,17 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                             v.StringSchema<undefined>,
                             undefined
                           >;
+                          /**
+                           * When true, the caller MUST supply this entry at start (via
+                           * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                           * missing required entry throws rather than silently defaulting to
+                           * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                           * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                           */
+                          readonly required: v.OptionalSchema<
+                            v.BooleanSchema<undefined>,
+                            undefined
+                          >;
                           readonly source: v.GenericSchema<SourceInternal>;
                         },
                         undefined
@@ -6056,6 +6238,11 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                   description?: string | undefined;
                   activation?: "auto" | "manual" | undefined;
                   filter?: string | undefined;
+                  requirements?:
+                    | {
+                        [x: string]: string;
+                      }
+                    | undefined;
                   completeWhen?: string | undefined;
                   failWhen?: string | undefined;
                   ops?:
@@ -6374,6 +6561,7 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                             name: string;
                             title?: string | undefined;
                             description?: string | undefined;
+                            required?: boolean | undefined;
                             source: SourceInternal;
                           }
                         | {
@@ -6515,6 +6703,7 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
                       name: string;
                       title?: string | undefined;
                       description?: string | undefined;
+                      required?: boolean | undefined;
                       source: SourceInternal;
                     }
                   | {
@@ -6879,6 +7068,22 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
       ]
     >;
     description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Whether a human may start this workflow standalone. `'child'` marks a
+     * spawn-only definition — instantiated by a parent via `task.subworkflows`,
+     * never started cold from a picker. Omitted ⇒ `'workflow'` (startable).
+     * Advisory: consumers filter their start pickers on it (see
+     * {@link isStartableDefinition}); the engine does NOT refuse a
+     * `startInstance` on a `'child'` def — load-bearing `required` state is the
+     * runtime backstop.
+     */
+    role: v.OptionalSchema<
+      v.PicklistSchema<
+        readonly ["workflow", "child"],
+        `Invalid option: expected one of ${string}`
+      >,
+      undefined
+    >;
     /** Reference field: named for the target, holds the stage's `name`. */
     initialStage: v.SchemaWithPipe<
       readonly [
@@ -6923,6 +7128,17 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
               v.StringSchema<undefined>,
               undefined
             >;
+            /**
+             * When true, the caller MUST supply this entry at start (via
+             * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+             * missing required entry throws rather than silently defaulting to
+             * `null`/`[]` — the same fail-fast an action's `required` param gets.
+             * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+             */
+            readonly required: v.OptionalSchema<
+              v.BooleanSchema<undefined>,
+              undefined
+            >;
             readonly source: v.GenericSchema<SourceInternal>;
           },
           undefined
@@ -6989,6 +7205,41 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                         >,
                         undefined
                       >;
+                      /**
+                       * Readiness gates, by name — conditions over the rendered scope that must
+                       * hold for the task to be *executable*, orthogonal to `filter`
+                       * (visibility). An unmet requirement keeps the task visible but disables
+                       * its actions with a `requirements-unmet` verdict naming the unmet keys;
+                       * all must hold (any-of lives inside one condition). Advisory like every
+                       * engine gate — the lake still enforces. Distinct from ACL (authorization)
+                       * and guards (content-write locks).
+                       */
+                      requirements: v.OptionalSchema<
+                        v.RecordSchema<
+                          v.SchemaWithPipe<
+                            readonly [
+                              v.StringSchema<undefined>,
+                              v.MinLengthAction<
+                                string,
+                                1,
+                                "must be a non-empty string"
+                              >,
+                            ]
+                          >,
+                          v.SchemaWithPipe<
+                            readonly [
+                              v.StringSchema<undefined>,
+                              v.MinLengthAction<
+                                string,
+                                1,
+                                "must be a non-empty string"
+                              >,
+                            ]
+                          >,
+                          undefined
+                        >,
+                        undefined
+                      >;
                       /**
                        * Auto-completion condition — evaluated at activation and on every
                        * cascade; truthy flips the task to `done` with a system actor. On a
@@ -7772,6 +8023,17 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                                 v.StringSchema<undefined>,
                                 undefined
                               >;
+                              /**
+                               * When true, the caller MUST supply this entry at start (via
+                               * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                               * missing required entry throws rather than silently defaulting to
+                               * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                               * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                               */
+                              readonly required: v.OptionalSchema<
+                                v.BooleanSchema<undefined>,
+                                undefined
+                              >;
                               readonly source: v.GenericSchema<SourceInternal>;
                             },
                             undefined
@@ -8248,6 +8510,17 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                         v.StringSchema<undefined>,
                         undefined
                       >;
+                      /**
+                       * When true, the caller MUST supply this entry at start (via
+                       * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+                       * missing required entry throws rather than silently defaulting to
+                       * `null`/`[]` — the same fail-fast an action's `required` param gets.
+                       * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+                       */
+                      readonly required: v.OptionalSchema<
+                        v.BooleanSchema<undefined>,
+                        undefined
+                      >;
                       readonly source: v.GenericSchema<SourceInternal>;
                     },
                     undefined
@@ -8273,6 +8546,11 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                   description?: string | undefined;
                   activation?: "auto" | "manual" | undefined;
                   filter?: string | undefined;
+                  requirements?:
+                    | {
+                        [x: string]: string;
+                      }
+                    | undefined;
                   completeWhen?: string | undefined;
                   failWhen?: string | undefined;
                   ops?:
@@ -8481,6 +8759,7 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                         name: string;
                         title?: string | undefined;
                         description?: string | undefined;
+                        required?: boolean | undefined;
                         source: SourceInternal;
                       }[]
                     | undefined;
@@ -8600,6 +8879,7 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
                   name: string;
                   title?: string | undefined;
                   description?: string | undefined;
+                  required?: boolean | undefined;
                   source: SourceInternal;
                 }[]
               | undefined;