@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/flows-actors/meta-workflows/decisions.meta-workflows.shared.schemas.d.ts

@@ -0,0 +1,446 @@
+import { z } from 'zod';
+import { MetaWorkflow_DriverLifecycleFacet } from './actions.meta-workflows.shared.schemas';
+/** Cardinality and decision significance of one evidence requirement. */
+export declare enum MetaWorkflow_EvidenceRequirementKind {
+    MANDATORY = "MANDATORY",
+    CONDITIONAL = "CONDITIONAL",
+    ADVISORY = "ADVISORY"
+}
+/** Semantic class of an evaluator contract, never its implementation identity. */
+export declare enum MetaWorkflow_EvaluatorClass {
+    DETERMINISTIC = "DETERMINISTIC",
+    SEMANTIC_MODEL = "SEMANTIC_MODEL",
+    HUMAN_REVIEW = "HUMAN_REVIEW",
+    HYBRID = "HYBRID"
+}
+/** Decision-boundary class implemented by one declarative Decision Rule. */
+export declare enum MetaWorkflow_DecisionRuleBoundaryClass {
+    HARD_DETERMINISTIC = "HARD_DETERMINISTIC",
+    QUALITY_INTERPRETATION = "QUALITY_INTERPRETATION",
+    ADVISORY = "ADVISORY"
+}
+/** Valid semantic conclusion emitted only after a completed evaluator execution. */
+export declare enum MetaWorkflow_EvaluationVerdict {
+    PASS = "PASS",
+    CONCERN = "CONCERN",
+    GAP = "GAP",
+    INDETERMINATE = "INDETERMINATE"
+}
+/** One selected next step from a bounded assessment episode. */
+export declare enum MetaWorkflow_AssessmentAction {
+    REVISE_CANDIDATE = "REVISE_CANDIDATE",
+    REQUEST_EVIDENCE = "REQUEST_EVIDENCE",
+    CONTINUE = "CONTINUE",
+    DEFER_CONCERN = "DEFER_CONCERN",
+    REQUEST_DECISION = "REQUEST_DECISION",
+    STOP_GOOD_ENOUGH = "STOP_GOOD_ENOUGH",
+    PROPOSE_ACCEPTANCE = "PROPOSE_ACCEPTANCE"
+}
+/** Closed assembly contract for evaluator instructions and sealed evidence. */
+export declare enum MetaWorkflow_EvaluationPromptAssemblyStrategy {
+    CANONICAL_PROTOCOL_EVIDENCE_V1 = "CANONICAL_PROTOCOL_EVIDENCE_V1"
+}
+/** Closed aggregation contract for criterion-level semantic verdicts. */
+export declare enum MetaWorkflow_EvaluationAggregationStrategy {
+    WORST_VERDICT_PRECEDENCE_V1 = "WORST_VERDICT_PRECEDENCE_V1"
+}
+/** Consequence selected by a Decision Rule before continuation policy is applied. */
+export declare enum MetaWorkflow_DecisionConsequence {
+    CONTINUE = "CONTINUE",
+    REVISE = "REVISE",
+    REQUEST_EVIDENCE = "REQUEST_EVIDENCE",
+    REQUEST_AUTHORITY = "REQUEST_AUTHORITY",
+    BLOCK = "BLOCK",
+    CANCEL = "CANCEL"
+}
+/** Treatment-flow action produced by a Continuation Policy. */
+export declare enum MetaWorkflow_ContinuationAction {
+    CONTINUE = "CONTINUE",
+    REVISE = "REVISE",
+    REQUEST_EVIDENCE = "REQUEST_EVIDENCE",
+    REQUEST_AUTHORITY = "REQUEST_AUTHORITY",
+    BLOCK = "BLOCK",
+    CANCEL = "CANCEL"
+}
+/** Decision mechanism that actually produced an authority response. */
+export declare enum MetaWorkflow_AuthorityDecisionMode {
+    EXPLICIT_OPERATOR_CONFIRMATION = "EXPLICIT_OPERATOR_CONFIRMATION",
+    POLICY_DECISION = "POLICY_DECISION"
+}
+/** Assurance achieved by the selected authority channel. */
+export declare enum MetaWorkflow_AuthorityAssuranceClass {
+    LOCAL_OS_SESSION = "LOCAL_OS_SESSION",
+    AUTHENTICATED_PRINCIPAL = "AUTHENTICATED_PRINCIPAL"
+}
+/** Closed interaction channels understood by the generic authority membrane. */
+export declare enum MetaWorkflow_AuthorityInteractionChannel {
+    INTERFACE_RELAY = "INTERFACE_RELAY",
+    LOCAL_UI = "LOCAL_UI",
+    CLI_TTY = "CLI_TTY"
+}
+/** A hard floor is structurally non-waivable in every authority posture. */
+export declare enum MetaWorkflow_HardFloorPosture {
+    NON_WAIVABLE = "NON_WAIVABLE"
+}
+/** Portable schema identity for one executable treatment artifact. */
+export declare enum MetaWorkflow_ExecutionDefinitionSchemaRef {
+    EVALUATION_TREATMENT_V1 = "wildo:meta-workflow/evaluation-treatment-definition:v1",
+    STRUCTURED_ARTIFACT_ACTION_V1 = "wildo:meta-workflow/structured-artifact-action-definition:v1"
+}
+declare const _MetaWorkflow_EvaluationCriterionDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    criterionRef: z.ZodString;
+    criterionVersion: z.ZodNumber;
+    instruction: z.ZodString;
+    evidenceRequirements: z.ZodArray<z.ZodObject<{
+        requirementRef: z.ZodString;
+        requirementVersion: z.ZodNumber;
+    }, z.core.$strict>>;
+    verdictGuidance: z.ZodObject<{
+        PASS: z.ZodString;
+        CONCERN: z.ZodString;
+        GAP: z.ZodString;
+        INDETERMINATE: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type MetaWorkflow_EvaluationCriterionDefinition = z.infer<typeof _MetaWorkflow_EvaluationCriterionDefinitionSchema>;
+/** Runtime-neutral evaluator capability declaration. */
+declare const _MetaWorkflow_EvaluatorDescriptorSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    evaluatorRef: z.ZodString;
+    evaluatorVersion: z.ZodNumber;
+    evaluatorClass: z.ZodEnum<typeof MetaWorkflow_EvaluatorClass>;
+    acceptedEvidenceRequirementSchemaVersions: z.ZodArray<z.ZodNumber>;
+    evaluationOutputContract: z.ZodObject<{
+        descriptorRef: z.ZodString;
+        descriptorVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    admissibleDriverDescriptors: z.ZodArray<z.ZodObject<{
+        descriptorRef: z.ZodString;
+        descriptorVersion: z.ZodNumber;
+    }, z.core.$strict>>;
+    requiredCapabilityClassRefs: z.ZodArray<z.ZodString>;
+    requiredCapabilityFacetRefs: z.ZodArray<z.ZodString>;
+    requiredLifecycleFacets: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_DriverLifecycleFacet>>;
+    supportedBoundaryClasses: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_DecisionRuleBoundaryClass>>;
+    uncertaintyFacetRefs: z.ZodArray<z.ZodString>;
+    criterionResultFacetRefs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const MetaWorkflow_EvaluatorDescriptorSchema: typeof _MetaWorkflow_EvaluatorDescriptorSchema;
+export type MetaWorkflow_EvaluatorDescriptor = z.infer<typeof _MetaWorkflow_EvaluatorDescriptorSchema>;
+/**
+ * Model-owned semantic claims only. Runtime-owned identity, aggregation and
+ * provenance are intentionally absent so an LLM cannot counterfeit them.
+ */
+declare const _MetaWorkflow_StructuredSemanticModelOutputV1Schema: z.ZodObject<{
+    outputVersion: z.ZodLiteral<1>;
+    criterionResults: z.ZodArray<z.ZodObject<{
+        criterionRef: z.ZodString;
+        verdict: z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>;
+        score: z.ZodNullable<z.ZodNumber>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        rationale: z.ZodString;
+    }, z.core.$strict>>;
+    discoveredFindings: z.ZodArray<z.ZodObject<{
+        findingKey: z.ZodString;
+        materiality: z.ZodNumber;
+        uncertainty: z.ZodNumber;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        rationale: z.ZodString;
+    }, z.core.$strict>>;
+    actionProposals: z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<typeof MetaWorkflow_AssessmentAction>;
+        /**
+         * Provider-portable proposal payload. The runtime maps these two fields into
+         * the action-specific durable payload and rejects an invalid combination.
+         * Keeping the model boundary flat avoids `oneOf`, which is not accepted by
+         * every strict structured-output provider.
+         */
+        payloadRefs: z.ZodArray<z.ZodString>;
+        payloadText: z.ZodNullable<z.ZodString>;
+        criterionRefs: z.ZodArray<z.ZodString>;
+        findingKeys: z.ZodArray<z.ZodString>;
+        rationale: z.ZodString;
+    }, z.core.$strict>>;
+    missingEvidenceRequirementRefs: z.ZodArray<z.ZodString>;
+    conflictingEvidenceRefs: z.ZodArray<z.ZodString>;
+    uncertainty: z.ZodNumber;
+    /**
+     * Bounded semantic advice for application composition. These are not
+     * authority claims: deterministic hard floors, declared playbook bounds,
+     * and resource ceilings still decide whether the suggested posture is
+     * admissible. Explicit `null` is the settled-evaluation posture; dynamic
+     * working episodes refuse it before composition. Requiring the property on
+     * the provider boundary keeps the schema compatible with strict structured
+     * output without treating missing data as implicit policy.
+     *
+     * Full hierarchical/scoped posture is intentionally a later extension. The
+     * v0 boolean concerns only this sealed assessment scope; it is not a global
+     * application-wide deferral permission.
+     */
+    assessmentAdvice: z.ZodNullable<z.ZodObject<{
+        maturity: z.ZodNumber;
+        likelyImprovement: z.ZodNumber;
+        scopedConcernCanDefer: z.ZodBoolean;
+        materialOperatorDecisionRequired: z.ZodBoolean;
+    }, z.core.$strict>>;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const MetaWorkflow_StructuredSemanticModelOutputV1Schema: typeof _MetaWorkflow_StructuredSemanticModelOutputV1Schema;
+/** Closed result mapping, not a general expression or fuzzy-rule DSL. */
+declare const _MetaWorkflow_DecisionRuleSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    ruleRef: z.ZodString;
+    ruleVersion: z.ZodNumber;
+    boundaryClass: z.ZodEnum<typeof MetaWorkflow_DecisionRuleBoundaryClass>;
+    evidenceAggregationRef: z.ZodString;
+    resultMappings: z.ZodArray<z.ZodObject<{
+        verdict: z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>;
+        consequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+    }, z.core.$strict>>;
+    hardFloorBindings: z.ZodArray<z.ZodObject<{
+        hardFloorRef: z.ZodString;
+        evidenceRequirementRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    hardFloorFailureConsequence: z.ZodLiteral<MetaWorkflow_DecisionConsequence.BLOCK>;
+    hardFloorShortcutAllowed: z.ZodLiteral<false>;
+    unresolvedConsequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+    evaluatorFailureConsequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+}, z.core.$strict>;
+export type MetaWorkflow_DecisionRule = z.infer<typeof _MetaWorkflow_DecisionRuleSchema>;
+/** Declared human/operator authority membrane. */
+declare const _MetaWorkflow_AuthorityRequirementSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requirementRef: z.ZodString;
+    requirementVersion: z.ZodNumber;
+    consequenceClassRef: z.ZodString;
+    riskClassRef: z.ZodString;
+    decisionModePolicyRef: z.ZodString;
+    assurancePolicyRef: z.ZodString;
+    channelPolicyRef: z.ZodString;
+    principalPolicyRef: z.ZodNullable<z.ZodString>;
+    requiredDecisionMode: z.ZodEnum<typeof MetaWorkflow_AuthorityDecisionMode>;
+    minimumAssurance: z.ZodEnum<typeof MetaWorkflow_AuthorityAssuranceClass>;
+    admittedChannels: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_AuthorityInteractionChannel>>;
+    requiredEvidenceRequirementRefs: z.ZodArray<z.ZodString>;
+    expiryPolicyRef: z.ZodString;
+    noncePolicyRef: z.ZodString;
+    hardFloorPosture: z.ZodLiteral<MetaWorkflow_HardFloorPosture>;
+    hardFloorOverrideAllowed: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type MetaWorkflow_AuthorityRequirement = z.infer<typeof _MetaWorkflow_AuthorityRequirementSchema>;
+/** Stable semantic Decision Point declaration. */
+declare const _MetaWorkflow_DecisionPointDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    decisionPointRef: z.ZodString;
+    decisionPointVersion: z.ZodNumber;
+    triggerRefs: z.ZodArray<z.ZodString>;
+    evidenceRequirements: z.ZodArray<z.ZodObject<{
+        requirementRef: z.ZodString;
+        requirementVersion: z.ZodNumber;
+    }, z.core.$strict>>;
+    evaluatorBindingPolicy: z.ZodObject<{
+        policyRef: z.ZodString;
+        policyVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    decisionRule: z.ZodObject<{
+        ruleRef: z.ZodString;
+        ruleVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    authorityRequirement: z.ZodNullable<z.ZodObject<{
+        requirementRef: z.ZodString;
+        requirementVersion: z.ZodNumber;
+    }, z.core.$strict>>;
+    continuationPolicy: z.ZodObject<{
+        policyRef: z.ZodString;
+        policyVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    hardFloorRefs: z.ZodArray<z.ZodString>;
+    riskPolicyRef: z.ZodString;
+    significancePolicyRef: z.ZodString;
+}, z.core.$strict>;
+export type MetaWorkflow_DecisionPointDefinition = z.infer<typeof _MetaWorkflow_DecisionPointDefinitionSchema>;
+/** Treatment-flow policy; it has no application-truth mutation operation. */
+declare const _MetaWorkflow_ContinuationPolicySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    policyRef: z.ZodString;
+    policyVersion: z.ZodNumber;
+    mappings: z.ZodArray<z.ZodObject<{
+        decisionConsequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+        action: z.ZodEnum<typeof MetaWorkflow_ContinuationAction>;
+    }, z.core.$strict>>;
+    maximumRevisionAttempts: z.ZodNumber;
+    maximumEvidenceRequests: z.ZodNumber;
+    maximumAuthorityReviews: z.ZodNumber;
+    fallbackAction: z.ZodEnum<{
+        BLOCK: MetaWorkflow_ContinuationAction.BLOCK;
+        CANCEL: MetaWorkflow_ContinuationAction.CANCEL;
+    }>;
+}, z.core.$strict>;
+export type MetaWorkflow_ContinuationPolicy = z.infer<typeof _MetaWorkflow_ContinuationPolicySchema>;
+/**
+ * One self-contained executable decision treatment.
+ *
+ * Every member is carried in full so a catalog artifact has no ambient
+ * semantic dependency. The backend integrity validator recomputes each nested
+ * identity and checks that the Decision Point identities refer to these exact
+ * members.
+ */
+declare const _MetaWorkflow_EvaluationTreatmentDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    definitionRef: z.ZodString;
+    definitionVersion: z.ZodNumber;
+    evaluationProtocol: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        protocolRef: z.ZodString;
+        protocolVersion: z.ZodNumber;
+        criteria: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            criterionRef: z.ZodString;
+            criterionVersion: z.ZodNumber;
+            instruction: z.ZodString;
+            evidenceRequirements: z.ZodArray<z.ZodObject<{
+                requirementRef: z.ZodString;
+                requirementVersion: z.ZodNumber;
+            }, z.core.$strict>>;
+            verdictGuidance: z.ZodObject<{
+                PASS: z.ZodString;
+                CONCERN: z.ZodString;
+                GAP: z.ZodString;
+                INDETERMINATE: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        promptAssemblyStrategy: z.ZodLiteral<MetaWorkflow_EvaluationPromptAssemblyStrategy>;
+        aggregationStrategy: z.ZodLiteral<MetaWorkflow_EvaluationAggregationStrategy>;
+        verdictPrecedence: z.ZodTuple<[z.ZodLiteral<MetaWorkflow_EvaluationVerdict.GAP>, z.ZodLiteral<MetaWorkflow_EvaluationVerdict.INDETERMINATE>, z.ZodLiteral<MetaWorkflow_EvaluationVerdict.CONCERN>, z.ZodLiteral<MetaWorkflow_EvaluationVerdict.PASS>], null>;
+        aggregationPolicyRef: z.ZodString;
+        provenance: z.ZodObject<{
+            sourcePlaybookRef: z.ZodString;
+            compilerRef: z.ZodString;
+            compilerVersion: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    evidenceRequirements: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        requirementRef: z.ZodString;
+        requirementVersion: z.ZodNumber;
+        kind: z.ZodEnum<typeof MetaWorkflow_EvidenceRequirementKind>;
+        criterionRef: z.ZodString;
+        subjectRef: z.ZodString;
+        minCount: z.ZodNumber;
+        maxCount: z.ZodNullable<z.ZodNumber>;
+        coveragePolicyRef: z.ZodString;
+        freshnessPolicyRef: z.ZodString;
+        conditionRef: z.ZodNullable<z.ZodString>;
+        independencePolicyRef: z.ZodNullable<z.ZodString>;
+        diversityPolicyRef: z.ZodNullable<z.ZodString>;
+        aggregationPolicyRef: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    evaluatorBindingPolicy: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        policyRef: z.ZodString;
+        policyVersion: z.ZodNumber;
+        admissibleEvaluatorDescriptors: z.ZodArray<z.ZodObject<{
+            descriptorRef: z.ZodString;
+            descriptorVersion: z.ZodNumber;
+        }, z.core.$strict>>;
+        defaultEvaluatorDescriptor: z.ZodObject<{
+            descriptorRef: z.ZodString;
+            descriptorVersion: z.ZodNumber;
+        }, z.core.$strict>;
+        fallbackPolicyRef: z.ZodString;
+        escalationPolicyRef: z.ZodString;
+        maximumAttempts: z.ZodNumber;
+        timeoutPolicyRef: z.ZodString;
+        budgetPolicyRef: z.ZodString;
+        outputSchemaRef: z.ZodString;
+        selectionPolicyRef: z.ZodString;
+    }, z.core.$strict>;
+    decisionPointDefinition: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        decisionPointRef: z.ZodString;
+        decisionPointVersion: z.ZodNumber;
+        triggerRefs: z.ZodArray<z.ZodString>;
+        evidenceRequirements: z.ZodArray<z.ZodObject<{
+            requirementRef: z.ZodString;
+            requirementVersion: z.ZodNumber;
+        }, z.core.$strict>>;
+        evaluatorBindingPolicy: z.ZodObject<{
+            policyRef: z.ZodString;
+            policyVersion: z.ZodNumber;
+        }, z.core.$strict>;
+        decisionRule: z.ZodObject<{
+            ruleRef: z.ZodString;
+            ruleVersion: z.ZodNumber;
+        }, z.core.$strict>;
+        authorityRequirement: z.ZodNullable<z.ZodObject<{
+            requirementRef: z.ZodString;
+            requirementVersion: z.ZodNumber;
+        }, z.core.$strict>>;
+        continuationPolicy: z.ZodObject<{
+            policyRef: z.ZodString;
+            policyVersion: z.ZodNumber;
+        }, z.core.$strict>;
+        hardFloorRefs: z.ZodArray<z.ZodString>;
+        riskPolicyRef: z.ZodString;
+        significancePolicyRef: z.ZodString;
+    }, z.core.$strict>;
+    decisionRule: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        ruleRef: z.ZodString;
+        ruleVersion: z.ZodNumber;
+        boundaryClass: z.ZodEnum<typeof MetaWorkflow_DecisionRuleBoundaryClass>;
+        evidenceAggregationRef: z.ZodString;
+        resultMappings: z.ZodArray<z.ZodObject<{
+            verdict: z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>;
+            consequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+        }, z.core.$strict>>;
+        hardFloorBindings: z.ZodArray<z.ZodObject<{
+            hardFloorRef: z.ZodString;
+            evidenceRequirementRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        hardFloorFailureConsequence: z.ZodLiteral<MetaWorkflow_DecisionConsequence.BLOCK>;
+        hardFloorShortcutAllowed: z.ZodLiteral<false>;
+        unresolvedConsequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+        evaluatorFailureConsequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+    }, z.core.$strict>;
+    authorityRequirement: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        requirementRef: z.ZodString;
+        requirementVersion: z.ZodNumber;
+        consequenceClassRef: z.ZodString;
+        riskClassRef: z.ZodString;
+        decisionModePolicyRef: z.ZodString;
+        assurancePolicyRef: z.ZodString;
+        channelPolicyRef: z.ZodString;
+        principalPolicyRef: z.ZodNullable<z.ZodString>;
+        requiredDecisionMode: z.ZodEnum<typeof MetaWorkflow_AuthorityDecisionMode>;
+        minimumAssurance: z.ZodEnum<typeof MetaWorkflow_AuthorityAssuranceClass>;
+        admittedChannels: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_AuthorityInteractionChannel>>;
+        requiredEvidenceRequirementRefs: z.ZodArray<z.ZodString>;
+        expiryPolicyRef: z.ZodString;
+        noncePolicyRef: z.ZodString;
+        hardFloorPosture: z.ZodLiteral<MetaWorkflow_HardFloorPosture>;
+        hardFloorOverrideAllowed: z.ZodLiteral<false>;
+    }, z.core.$strict>>;
+    continuationPolicy: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        policyRef: z.ZodString;
+        policyVersion: z.ZodNumber;
+        mappings: z.ZodArray<z.ZodObject<{
+            decisionConsequence: z.ZodEnum<typeof MetaWorkflow_DecisionConsequence>;
+            action: z.ZodEnum<typeof MetaWorkflow_ContinuationAction>;
+        }, z.core.$strict>>;
+        maximumRevisionAttempts: z.ZodNumber;
+        maximumEvidenceRequests: z.ZodNumber;
+        maximumAuthorityReviews: z.ZodNumber;
+        fallbackAction: z.ZodEnum<{
+            BLOCK: MetaWorkflow_ContinuationAction.BLOCK;
+            CANCEL: MetaWorkflow_ContinuationAction.CANCEL;
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const MetaWorkflow_EvaluationTreatmentDefinitionSchema: typeof _MetaWorkflow_EvaluationTreatmentDefinitionSchema;
+export type MetaWorkflow_EvaluationTreatmentDefinition = z.infer<typeof _MetaWorkflow_EvaluationTreatmentDefinitionSchema>;
+export {};
+//# sourceMappingURL=decisions.meta-workflows.shared.schemas.d.ts.map

package/dist/esm/flows-actors/meta-workflows/decisions.meta-workflows.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decisions.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/decisions.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"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"}