@schnick371/devsteps-shared 1.1.0-next.4 → 2.0.0-next.1

package/dist/schemas/workflow-definition-v2.d.ts

@@ -0,0 +1,554 @@
+/**
+ * Copyright © 2026 Thomas Hertel (the@devsteps.dev)
+ * Licensed under the Apache License, Version 2.0
+ *
+ * Compiled workflow authoring contract.
+ * Keeps tool bindings, parameters, outcomes, human interaction, and recovery declarative.
+ */
+import { z } from 'zod';
+export * from './workflow-v2-contracts.js';
+export * from './workflow-v2-vocabulary.js';
+export declare const WorkflowStep: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        artifact: "artifact";
+        cleanup: "cleanup";
+        human: "human";
+        predicate: "predicate";
+        script: "script";
+        semantic_judgment: "semantic_judgment";
+        tool: "tool";
+    }>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    optional: z.ZodDefault<z.ZodBoolean>;
+    timeout_seconds: z.ZodDefault<z.ZodNumber>;
+    side_effect: z.ZodEnum<{
+        credentialed: "credentialed";
+        irreversible: "irreversible";
+        "local-destructive": "local-destructive";
+        "local-reversible": "local-reversible";
+        "read-only": "read-only";
+        "remote-mutating": "remote-mutating";
+        "remote-reversible": "remote-reversible";
+    }>;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+    arguments_template: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    expected_results: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    binding: z.ZodOptional<z.ZodObject<{
+        server_tool_name: z.ZodOptional<z.ZodString>;
+        host_tool_name: z.ZodString;
+        host_profile: z.ZodOptional<z.ZodString>;
+        input_schema_digest: z.ZodOptional<z.ZodString>;
+        output_schema_digest: z.ZodOptional<z.ZodString>;
+        protocol_version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    human: z.ZodOptional<z.ZodObject<{
+        interaction: z.ZodEnum<{
+            approval: "approval";
+            manual_action: "manual_action";
+            observation: "observation";
+            question: "question";
+        }>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            claude_code_ask_user_question: "claude_code_ask_user_question";
+            conversation: "conversation";
+            vscode_askQuestions: "vscode_askQuestions";
+            vscode_walkthrough_panel: "vscode_walkthrough_panel";
+        }>>;
+        instruction: z.ZodString;
+        expected_observation: z.ZodOptional<z.ZodString>;
+        options: z.ZodArray<z.ZodString>;
+        allow_freeform: z.ZodDefault<z.ZodBoolean>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        prevalidate: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        bypass_when: z.ZodDefault<z.ZodEnum<{
+            all_pass: "all_pass";
+            never: "never";
+        }>>;
+        response_mapping: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            BLOCKED: "BLOCKED";
+            CANCELLED: "CANCELLED";
+            FAIL: "FAIL";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            NOT_RECORDED: "NOT_RECORDED";
+            PASS: "PASS";
+        }>>;
+        on_unavailable: z.ZodDefault<z.ZodEnum<{
+            "declared-fallback": "declared-fallback";
+            pause: "pause";
+        }>>;
+        evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    semantic_judgment: z.ZodOptional<z.ZodObject<{
+        rubric: z.ZodArray<z.ZodString>;
+        verdicts: z.ZodArray<z.ZodEnum<{
+            BLOCKED: "BLOCKED";
+            CANCELLED: "CANCELLED";
+            FAIL: "FAIL";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            NOT_RECORDED: "NOT_RECORDED";
+            PASS: "PASS";
+        }>>;
+        minimum_confidence: z.ZodNumber;
+        rationale_max_length: z.ZodDefault<z.ZodNumber>;
+        inconclusive_target: z.ZodString;
+    }, z.core.$strip>>;
+    retry: z.ZodDefault<z.ZodObject<{
+        max_attempts: z.ZodDefault<z.ZodNumber>;
+        on_codes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            ARTIFACT_INVALID: "ARTIFACT_INVALID";
+            ASSERTION_FAILED: "ASSERTION_FAILED";
+            AUTHORING_INVALID: "AUTHORING_INVALID";
+            BINDING_SCHEMA_DRIFT: "BINDING_SCHEMA_DRIFT";
+            BINDING_UNAVAILABLE: "BINDING_UNAVAILABLE";
+            CANCELLED: "CANCELLED";
+            EXECUTION_FAILED: "EXECUTION_FAILED";
+            HUMAN_DECLINED: "HUMAN_DECLINED";
+            INPUT_INVALID: "INPUT_INVALID";
+            INTERNAL_ERROR: "INTERNAL_ERROR";
+            MANIFEST_INTEGRITY: "MANIFEST_INTEGRITY";
+            PARAMETER_MUTATION: "PARAMETER_MUTATION";
+            PERSISTENCE_CONFLICT: "PERSISTENCE_CONFLICT";
+            POLICY_DENIED: "POLICY_DENIED";
+            PROTOCOL_ERROR: "PROTOCOL_ERROR";
+            SEMANTIC_INCONCLUSIVE: "SEMANTIC_INCONCLUSIVE";
+            TEMPLATE_ERROR: "TEMPLATE_ERROR";
+            TIMEOUT: "TIMEOUT";
+            TRANSPORT_ERROR: "TRANSPORT_ERROR";
+            UNCERTAIN_OUTCOME: "UNCERTAIN_OUTCOME";
+        }>>>;
+        backoff_ms: z.ZodDefault<z.ZodNumber>;
+        requires_idempotency: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    reconciliation_step: z.ZodOptional<z.ZodString>;
+    browser: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            "integrated-browser": "integrated-browser";
+            "playwright-mcp": "playwright-mcp";
+            "playwright-test": "playwright-test";
+            "run-playwright-code": "run-playwright-code";
+        }>;
+        script_path: z.ZodOptional<z.ZodString>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            tool_name: z.ZodString;
+            parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        }, z.core.$strip>>>;
+        assertions: z.ZodArray<z.ZodString>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            "blob-report": "blob-report";
+            "html-report": "html-report";
+            "json-report": "json-report";
+            screenshot: "screenshot";
+            trace: "trace";
+            video: "video";
+        }>>>;
+        dialog_route: z.ZodDefault<z.ZodEnum<{
+            escalate: "escalate";
+            fail: "fail";
+            repair: "repair";
+        }>>;
+        selector_drift_route: z.ZodDefault<z.ZodEnum<{
+            escalate: "escalate";
+            fail: "fail";
+            repair: "repair";
+        }>>;
+    }, z.core.$strip>>;
+    script: z.ZodOptional<z.ZodObject<{
+        shell: z.ZodEnum<{
+            bash: "bash";
+            cmd: "cmd";
+            pwsh: "pwsh";
+        }>;
+        working_directory: z.ZodOptional<z.ZodString>;
+        expect_json: z.ZodDefault<z.ZodBoolean>;
+        extract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    on: z.ZodObject<{
+        pass: z.ZodString;
+        fail: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strip>;
+    capture: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        response: "response";
+        screenshot: "screenshot";
+        stderr: "stderr";
+        stdout: "stdout";
+        trace: "trace";
+        video: "video";
+    }>>>;
+    evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            boolean: "boolean";
+            choice: "choice";
+            multiline: "multiline";
+            number: "number";
+            text: "text";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        help: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    why: z.ZodOptional<z.ZodString>;
+    stop: z.ZodOptional<z.ZodString>;
+    instruction: z.ZodOptional<z.ZodString>;
+    expected_observation: z.ZodOptional<z.ZodString>;
+    section: z.ZodOptional<z.ZodString>;
+    who: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        operator: "operator";
+    }>>;
+    max_passes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WorkflowStep = z.infer<typeof WorkflowStep>;
+export declare const WorkflowErrorRoute: z.ZodObject<{
+    code: z.ZodEnum<{
+        ARTIFACT_INVALID: "ARTIFACT_INVALID";
+        ASSERTION_FAILED: "ASSERTION_FAILED";
+        AUTHORING_INVALID: "AUTHORING_INVALID";
+        BINDING_SCHEMA_DRIFT: "BINDING_SCHEMA_DRIFT";
+        BINDING_UNAVAILABLE: "BINDING_UNAVAILABLE";
+        CANCELLED: "CANCELLED";
+        EXECUTION_FAILED: "EXECUTION_FAILED";
+        HUMAN_DECLINED: "HUMAN_DECLINED";
+        INPUT_INVALID: "INPUT_INVALID";
+        INTERNAL_ERROR: "INTERNAL_ERROR";
+        MANIFEST_INTEGRITY: "MANIFEST_INTEGRITY";
+        PARAMETER_MUTATION: "PARAMETER_MUTATION";
+        PERSISTENCE_CONFLICT: "PERSISTENCE_CONFLICT";
+        POLICY_DENIED: "POLICY_DENIED";
+        PROTOCOL_ERROR: "PROTOCOL_ERROR";
+        SEMANTIC_INCONCLUSIVE: "SEMANTIC_INCONCLUSIVE";
+        TEMPLATE_ERROR: "TEMPLATE_ERROR";
+        TIMEOUT: "TIMEOUT";
+        TRANSPORT_ERROR: "TRANSPORT_ERROR";
+        UNCERTAIN_OUTCOME: "UNCERTAIN_OUTCOME";
+    }>;
+    disposition: z.ZodEnum<{
+        escalate: "escalate";
+        fail: "fail";
+        pause: "pause";
+        reconcile: "reconcile";
+        repair: "repair";
+        retry: "retry";
+    }>;
+    target: z.ZodString;
+}, z.core.$strip>;
+export declare const WorkflowDefinitionV2: z.ZodObject<{
+    schema_version: z.ZodLiteral<"2.0">;
+    process_type: z.ZodString;
+    profile: z.ZodOptional<z.ZodEnum<{
+        "autonomous-guide": "autonomous-guide";
+        "human-guided-guide": "human-guided-guide";
+    }>>;
+    host_profiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tools: z.ZodArray<z.ZodObject<{
+            host_tool_name: z.ZodString;
+            kinds: z.ZodArray<z.ZodEnum<{
+                artifact: "artifact";
+                cleanup: "cleanup";
+                script: "script";
+                tool: "tool";
+            }>>;
+            argument_schema: z.ZodOptional<z.ZodObject<{
+                properties: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                required: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                additionalProperties: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        human_transport: z.ZodEnum<{
+            claude_code_ask_user_question: "claude_code_ask_user_question";
+            conversation: "conversation";
+            vscode_askQuestions: "vscode_askQuestions";
+            vscode_walkthrough_panel: "vscode_walkthrough_panel";
+        }>;
+    }, z.core.$strip>>>;
+    variables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            json: "json";
+            number: "number";
+            path: "path";
+            "secret-reference": "secret-reference";
+            string: "string";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            artifact: "artifact";
+            cleanup: "cleanup";
+            human: "human";
+            predicate: "predicate";
+            script: "script";
+            semantic_judgment: "semantic_judgment";
+            tool: "tool";
+        }>;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        optional: z.ZodDefault<z.ZodBoolean>;
+        timeout_seconds: z.ZodDefault<z.ZodNumber>;
+        side_effect: z.ZodEnum<{
+            credentialed: "credentialed";
+            irreversible: "irreversible";
+            "local-destructive": "local-destructive";
+            "local-reversible": "local-reversible";
+            "read-only": "read-only";
+            "remote-mutating": "remote-mutating";
+            "remote-reversible": "remote-reversible";
+        }>;
+        idempotency_key: z.ZodOptional<z.ZodString>;
+        arguments_template: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        expected_results: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        binding: z.ZodOptional<z.ZodObject<{
+            server_tool_name: z.ZodOptional<z.ZodString>;
+            host_tool_name: z.ZodString;
+            host_profile: z.ZodOptional<z.ZodString>;
+            input_schema_digest: z.ZodOptional<z.ZodString>;
+            output_schema_digest: z.ZodOptional<z.ZodString>;
+            protocol_version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        human: z.ZodOptional<z.ZodObject<{
+            interaction: z.ZodEnum<{
+                approval: "approval";
+                manual_action: "manual_action";
+                observation: "observation";
+                question: "question";
+            }>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                claude_code_ask_user_question: "claude_code_ask_user_question";
+                conversation: "conversation";
+                vscode_askQuestions: "vscode_askQuestions";
+                vscode_walkthrough_panel: "vscode_walkthrough_panel";
+            }>>;
+            instruction: z.ZodString;
+            expected_observation: z.ZodOptional<z.ZodString>;
+            options: z.ZodArray<z.ZodString>;
+            allow_freeform: z.ZodDefault<z.ZodBoolean>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            prevalidate: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            bypass_when: z.ZodDefault<z.ZodEnum<{
+                all_pass: "all_pass";
+                never: "never";
+            }>>;
+            response_mapping: z.ZodRecord<z.ZodString, z.ZodEnum<{
+                BLOCKED: "BLOCKED";
+                CANCELLED: "CANCELLED";
+                FAIL: "FAIL";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                NOT_RECORDED: "NOT_RECORDED";
+                PASS: "PASS";
+            }>>;
+            on_unavailable: z.ZodDefault<z.ZodEnum<{
+                "declared-fallback": "declared-fallback";
+                pause: "pause";
+            }>>;
+            evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        semantic_judgment: z.ZodOptional<z.ZodObject<{
+            rubric: z.ZodArray<z.ZodString>;
+            verdicts: z.ZodArray<z.ZodEnum<{
+                BLOCKED: "BLOCKED";
+                CANCELLED: "CANCELLED";
+                FAIL: "FAIL";
+                INCONCLUSIVE: "INCONCLUSIVE";
+                NOT_RECORDED: "NOT_RECORDED";
+                PASS: "PASS";
+            }>>;
+            minimum_confidence: z.ZodNumber;
+            rationale_max_length: z.ZodDefault<z.ZodNumber>;
+            inconclusive_target: z.ZodString;
+        }, z.core.$strip>>;
+        retry: z.ZodDefault<z.ZodObject<{
+            max_attempts: z.ZodDefault<z.ZodNumber>;
+            on_codes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                ARTIFACT_INVALID: "ARTIFACT_INVALID";
+                ASSERTION_FAILED: "ASSERTION_FAILED";
+                AUTHORING_INVALID: "AUTHORING_INVALID";
+                BINDING_SCHEMA_DRIFT: "BINDING_SCHEMA_DRIFT";
+                BINDING_UNAVAILABLE: "BINDING_UNAVAILABLE";
+                CANCELLED: "CANCELLED";
+                EXECUTION_FAILED: "EXECUTION_FAILED";
+                HUMAN_DECLINED: "HUMAN_DECLINED";
+                INPUT_INVALID: "INPUT_INVALID";
+                INTERNAL_ERROR: "INTERNAL_ERROR";
+                MANIFEST_INTEGRITY: "MANIFEST_INTEGRITY";
+                PARAMETER_MUTATION: "PARAMETER_MUTATION";
+                PERSISTENCE_CONFLICT: "PERSISTENCE_CONFLICT";
+                POLICY_DENIED: "POLICY_DENIED";
+                PROTOCOL_ERROR: "PROTOCOL_ERROR";
+                SEMANTIC_INCONCLUSIVE: "SEMANTIC_INCONCLUSIVE";
+                TEMPLATE_ERROR: "TEMPLATE_ERROR";
+                TIMEOUT: "TIMEOUT";
+                TRANSPORT_ERROR: "TRANSPORT_ERROR";
+                UNCERTAIN_OUTCOME: "UNCERTAIN_OUTCOME";
+            }>>>;
+            backoff_ms: z.ZodDefault<z.ZodNumber>;
+            requires_idempotency: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        reconciliation_step: z.ZodOptional<z.ZodString>;
+        browser: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                "integrated-browser": "integrated-browser";
+                "playwright-mcp": "playwright-mcp";
+                "playwright-test": "playwright-test";
+                "run-playwright-code": "run-playwright-code";
+            }>;
+            script_path: z.ZodOptional<z.ZodString>;
+            actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                tool_name: z.ZodString;
+                parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            }, z.core.$strip>>>;
+            assertions: z.ZodArray<z.ZodString>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                "blob-report": "blob-report";
+                "html-report": "html-report";
+                "json-report": "json-report";
+                screenshot: "screenshot";
+                trace: "trace";
+                video: "video";
+            }>>>;
+            dialog_route: z.ZodDefault<z.ZodEnum<{
+                escalate: "escalate";
+                fail: "fail";
+                repair: "repair";
+            }>>;
+            selector_drift_route: z.ZodDefault<z.ZodEnum<{
+                escalate: "escalate";
+                fail: "fail";
+                repair: "repair";
+            }>>;
+        }, z.core.$strip>>;
+        script: z.ZodOptional<z.ZodObject<{
+            shell: z.ZodEnum<{
+                bash: "bash";
+                cmd: "cmd";
+                pwsh: "pwsh";
+            }>;
+            working_directory: z.ZodOptional<z.ZodString>;
+            expect_json: z.ZodDefault<z.ZodBoolean>;
+            extract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        on: z.ZodObject<{
+            pass: z.ZodString;
+            fail: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strip>;
+        capture: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            response: "response";
+            screenshot: "screenshot";
+            stderr: "stderr";
+            stdout: "stdout";
+            trace: "trace";
+            video: "video";
+        }>>>;
+        evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                boolean: "boolean";
+                choice: "choice";
+                multiline: "multiline";
+                number: "number";
+                text: "text";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            help: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        why: z.ZodOptional<z.ZodString>;
+        stop: z.ZodOptional<z.ZodString>;
+        instruction: z.ZodOptional<z.ZodString>;
+        expected_observation: z.ZodOptional<z.ZodString>;
+        section: z.ZodOptional<z.ZodString>;
+        who: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>>;
+        max_passes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    predicates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            "artifact-count": "artifact-count";
+            "digest-check": "digest-check";
+            equals: "equals";
+            "file-check": "file-check";
+            "in-set": "in-set";
+            "json-path-equals": "json-path-equals";
+            "number-compare": "number-compare";
+            "origin-check": "origin-check";
+            "playwright-assertion": "playwright-assertion";
+            "schema-valid": "schema-valid";
+            "text-contains": "text-contains";
+            "text-normalized-equals": "text-normalized-equals";
+            "text-regex": "text-regex";
+        }>;
+        parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    }, z.core.$strip>>>;
+    error_routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            ARTIFACT_INVALID: "ARTIFACT_INVALID";
+            ASSERTION_FAILED: "ASSERTION_FAILED";
+            AUTHORING_INVALID: "AUTHORING_INVALID";
+            BINDING_SCHEMA_DRIFT: "BINDING_SCHEMA_DRIFT";
+            BINDING_UNAVAILABLE: "BINDING_UNAVAILABLE";
+            CANCELLED: "CANCELLED";
+            EXECUTION_FAILED: "EXECUTION_FAILED";
+            HUMAN_DECLINED: "HUMAN_DECLINED";
+            INPUT_INVALID: "INPUT_INVALID";
+            INTERNAL_ERROR: "INTERNAL_ERROR";
+            MANIFEST_INTEGRITY: "MANIFEST_INTEGRITY";
+            PARAMETER_MUTATION: "PARAMETER_MUTATION";
+            PERSISTENCE_CONFLICT: "PERSISTENCE_CONFLICT";
+            POLICY_DENIED: "POLICY_DENIED";
+            PROTOCOL_ERROR: "PROTOCOL_ERROR";
+            SEMANTIC_INCONCLUSIVE: "SEMANTIC_INCONCLUSIVE";
+            TEMPLATE_ERROR: "TEMPLATE_ERROR";
+            TIMEOUT: "TIMEOUT";
+            TRANSPORT_ERROR: "TRANSPORT_ERROR";
+            UNCERTAIN_OUTCOME: "UNCERTAIN_OUTCOME";
+        }>;
+        disposition: z.ZodEnum<{
+            escalate: "escalate";
+            fail: "fail";
+            pause: "pause";
+            reconcile: "reconcile";
+            repair: "repair";
+            retry: "retry";
+        }>;
+        target: z.ZodString;
+    }, z.core.$strip>>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        artifact_path: z.ZodOptional<z.ZodString>;
+        redacted: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    max_attempts: z.ZodDefault<z.ZodNumber>;
+    allow_parallel_runs: z.ZodOptional<z.ZodBoolean>;
+    sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        place: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodEnum<{
+            linux: "linux";
+            macos: "macos";
+            windows: "windows";
+        }>>;
+        remote: z.ZodOptional<z.ZodBoolean>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type WorkflowDefinitionV2 = z.infer<typeof WorkflowDefinitionV2>;
+//# sourceMappingURL=workflow-definition-v2.d.ts.map

package/dist/schemas/workflow-definition-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-definition-v2.d.ts","sourceRoot":"","sources":["../../src/schemas/workflow-definition-v2.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAiF5C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwB/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}