@jinn-network/client 0.1.6 → 0.1.7

package/dist/types/task-document.d.ts

@@ -15,6 +15,16 @@ export declare const TaskClaimPolicySchema: z.ZodObject<{
     submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
     claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
     policyHook: z.ZodOptional<z.ZodString>;
+    /**
+     * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+     * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+     * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+     * other (e.g. non-delivering) evaluators have already taken some slots —
+     * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+     * evaluator can monopolise all of them. Useful on a shared/adversarial
+     * network where verdict slots may be squatted.
+     */
+    requiredVerdicts: z.ZodOptional<z.ZodNumber>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
     maxClaims: z.ZodNumber;
@@ -24,6 +34,16 @@ export declare const TaskClaimPolicySchema: z.ZodObject<{
     submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
     claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
     policyHook: z.ZodOptional<z.ZodString>;
+    /**
+     * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+     * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+     * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+     * other (e.g. non-delivering) evaluators have already taken some slots —
+     * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+     * evaluator can monopolise all of them. Useful on a shared/adversarial
+     * network where verdict slots may be squatted.
+     */
+    requiredVerdicts: z.ZodOptional<z.ZodNumber>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
     maxClaims: z.ZodNumber;
@@ -33,6 +53,16 @@ export declare const TaskClaimPolicySchema: z.ZodObject<{
     submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
     claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
     policyHook: z.ZodOptional<z.ZodString>;
+    /**
+     * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+     * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+     * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+     * other (e.g. non-delivering) evaluators have already taken some slots —
+     * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+     * evaluator can monopolise all of them. Useful on a shared/adversarial
+     * network where verdict slots may be squatted.
+     */
+    requiredVerdicts: z.ZodOptional<z.ZodNumber>;
 }, z.ZodTypeAny, "passthrough">>;
 export type TaskClaimPolicy = z.infer<typeof TaskClaimPolicySchema>;
 export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
@@ -81,6 +111,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -90,6 +130,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -99,6 +149,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -157,6 +217,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -166,6 +236,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -175,6 +255,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -233,6 +323,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -242,6 +342,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -251,6 +361,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -309,6 +429,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -318,6 +448,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -327,6 +467,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -385,6 +535,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -394,6 +554,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -403,6 +573,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -439,6 +619,7 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         claimWindowEndTs?: number | undefined;
         submissionDeadlineTs?: number | undefined;
         policyHook?: string | undefined;
+        requiredVerdicts?: number | undefined;
     } & {
         [k: string]: unknown;
     };
@@ -493,6 +674,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -502,6 +693,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -511,6 +712,16 @@ export declare const TaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -587,6 +798,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -596,6 +817,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -605,6 +836,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -679,6 +920,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -688,6 +939,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -697,6 +958,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -771,6 +1042,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -780,6 +1061,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -789,6 +1080,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -863,6 +1164,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -872,6 +1183,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -881,6 +1202,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -955,6 +1286,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -964,6 +1305,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -973,6 +1324,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;
@@ -1015,6 +1376,7 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         claimWindowEndTs?: number | undefined;
         submissionDeadlineTs?: number | undefined;
         policyHook?: string | undefined;
+        requiredVerdicts?: number | undefined;
     } & {
         [k: string]: unknown;
     };
@@ -1085,6 +1447,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -1094,6 +1466,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         mode: z.ZodDefault<z.ZodEnum<["exclusive", "parallel"]>>;
         maxClaims: z.ZodNumber;
@@ -1103,6 +1485,16 @@ export declare const SignedTaskV1Schema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         submissionDeadlineTs: z.ZodOptional<z.ZodNumber>;
         claimLeaseTtlSeconds: z.ZodDefault<z.ZodNumber>;
         policyHook: z.ZodOptional<z.ZodString>;
+        /**
+         * On-chain `evaluationPolicy.requiredVerdicts` — the number of verdict
+         * claim slots per attempt. Optional; the adapter defaults it to 1. A value
+         * > 1 lets an honest evaluator still claim and deliver a verdict slot when
+         * other (e.g. non-delivering) evaluators have already taken some slots —
+         * the per-evaluator cap (`maxVerdictsPerEvaluator: 1`) means no single
+         * evaluator can monopolise all of them. Useful on a shared/adversarial
+         * network where verdict slots may be squatted.
+         */
+        requiredVerdicts: z.ZodOptional<z.ZodNumber>;
     }, z.ZodTypeAny, "passthrough">>;
     creator: z.ZodObject<{
         safeAddress: z.ZodString;