@cat-factory/contracts 0.35.0 → 0.36.0

package/dist/routes/human-review.d.ts

@@ -1,289 +1,288 @@
-import * as v from 'valibot';
 export declare const requestHumanReviewFixContract: {
     readonly method: "post";
-    readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly blockId: v.StringSchema<undefined>;
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        blockId: import("valibot").StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ blockId }: {
         blockId: string;
     }) => string;
-    readonly requestBodySchema: v.ObjectSchema<{
-        readonly instructions: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly instructions: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
     }, undefined>;
     readonly responsesByStatusCode: {
-        readonly '4xx': v.ObjectSchema<{
-            readonly error: v.ObjectSchema<{
-                readonly code: v.StringSchema<undefined>;
-                readonly message: v.StringSchema<undefined>;
-                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
-                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                    readonly message: v.StringSchema<undefined>;
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
                 }, undefined>, undefined>, undefined>;
             }, undefined>;
         }, undefined>;
-        readonly '5xx': v.ObjectSchema<{
-            readonly error: v.ObjectSchema<{
-                readonly code: v.StringSchema<undefined>;
-                readonly message: v.StringSchema<undefined>;
-                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
-                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                    readonly message: v.StringSchema<undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
                 }, undefined>, undefined>, undefined>;
             }, undefined>;
         }, undefined>;
-        readonly 200: v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly blockId: v.StringSchema<undefined>;
-            readonly pipelineId: v.StringSchema<undefined>;
-            readonly pipelineName: v.StringSchema<undefined>;
-            readonly steps: v.ArraySchema<v.ObjectSchema<{
-                readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly agentKind: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly state: v.PicklistSchema<["pending", "working", "waiting_decision", "done"], undefined>;
-                readonly progress: v.NumberSchema<undefined>;
-                readonly metrics: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly calls: v.NumberSchema<undefined>;
-                    readonly promptTokens: v.NumberSchema<undefined>;
-                    readonly completionTokens: v.NumberSchema<undefined>;
-                    readonly peakCompletionTokens: v.NumberSchema<undefined>;
-                    readonly maxOutputTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-                    readonly truncatedCalls: v.NumberSchema<undefined>;
-                    readonly upstreamMs: v.NumberSchema<undefined>;
-                    readonly overheadMs: v.NumberSchema<undefined>;
-                    readonly errors: v.NumberSchema<undefined>;
-                    readonly warnings: v.NumberSchema<undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly id: import("valibot").StringSchema<undefined>;
+            readonly blockId: import("valibot").StringSchema<undefined>;
+            readonly pipelineId: import("valibot").StringSchema<undefined>;
+            readonly pipelineName: import("valibot").StringSchema<undefined>;
+            readonly steps: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly runId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly agentKind: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
+                readonly state: import("valibot").PicklistSchema<["pending", "working", "waiting_decision", "done"], undefined>;
+                readonly progress: import("valibot").NumberSchema<undefined>;
+                readonly metrics: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly calls: import("valibot").NumberSchema<undefined>;
+                    readonly promptTokens: import("valibot").NumberSchema<undefined>;
+                    readonly completionTokens: import("valibot").NumberSchema<undefined>;
+                    readonly peakCompletionTokens: import("valibot").NumberSchema<undefined>;
+                    readonly maxOutputTokens: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly truncatedCalls: import("valibot").NumberSchema<undefined>;
+                    readonly upstreamMs: import("valibot").NumberSchema<undefined>;
+                    readonly overheadMs: import("valibot").NumberSchema<undefined>;
+                    readonly errors: import("valibot").NumberSchema<undefined>;
+                    readonly warnings: import("valibot").NumberSchema<undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly gate: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly phase: v.PicklistSchema<["checking", "working"], undefined>;
-                    readonly attempts: v.NumberSchema<undefined>;
-                    readonly maxAttempts: v.NumberSchema<undefined>;
-                    readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                    readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
-                    readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                    readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly name: v.StringSchema<undefined>;
-                        readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                        readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly gate: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly phase: import("valibot").PicklistSchema<["checking", "working"], undefined>;
+                    readonly attempts: import("valibot").NumberSchema<undefined>;
+                    readonly maxAttempts: import("valibot").NumberSchema<undefined>;
+                    readonly headSha: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly lastVerdict: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
+                    readonly lastFailureSummary: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly failingChecks: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly name: import("valibot").StringSchema<undefined>;
+                        readonly conclusion: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly url: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
                     }, undefined>, undefined>, undefined>, undefined>;
-                    readonly watchSince: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly watchWindowMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly regressedSignals: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly kind: v.PicklistSchema<["monitor", "slo"], undefined>;
-                        readonly id: v.StringSchema<undefined>;
-                        readonly name: v.StringSchema<undefined>;
-                        readonly state: v.PicklistSchema<["ok", "warn", "alert", "no_data"], undefined>;
-                        readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly watchSince: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly watchWindowMinutes: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly regressedSignals: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly kind: import("valibot").PicklistSchema<["monitor", "slo"], undefined>;
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly name: import("valibot").StringSchema<undefined>;
+                        readonly state: import("valibot").PicklistSchema<["ok", "warn", "alert", "no_data"], undefined>;
+                        readonly detail: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
                     }, undefined>, undefined>, undefined>, undefined>;
-                    readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly attempt: v.NumberSchema<undefined>;
-                        readonly at: v.NumberSchema<undefined>;
-                        readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-                        readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                        readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly attemptLog: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly attempt: import("valibot").NumberSchema<undefined>;
+                        readonly at: import("valibot").NumberSchema<undefined>;
+                        readonly outcome: import("valibot").PicklistSchema<["completed", "failed"], undefined>;
+                        readonly headSha: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly summary: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
                     }, undefined>, undefined>, undefined>, undefined>;
-                    readonly lastApprovals: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly requiredApprovingReviewCount: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly pendingThreadIds: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-                    readonly lastAddressedCommentAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly humanReviewGraceMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly pendingFix: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                        readonly instructions: v.StringSchema<undefined>;
-                        readonly at: v.NumberSchema<undefined>;
+                    readonly lastApprovals: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly requiredApprovingReviewCount: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly pendingThreadIds: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>;
+                    readonly lastAddressedCommentAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly humanReviewGraceMinutes: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly pendingFix: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                        readonly instructions: import("valibot").StringSchema<undefined>;
+                        readonly at: import("valibot").NumberSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly test: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly phase: v.PicklistSchema<["testing", "fixing"], undefined>;
-                    readonly attempts: v.NumberSchema<undefined>;
-                    readonly maxAttempts: v.NumberSchema<undefined>;
-                    readonly lastReport: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                        readonly greenlight: v.BooleanSchema<undefined>;
-                        readonly summary: v.StringSchema<undefined>;
-                        readonly tested: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-                        readonly outcomes: v.ArraySchema<v.ObjectSchema<{
-                            readonly name: v.StringSchema<undefined>;
-                            readonly status: v.PicklistSchema<["passed", "failed", "skipped"], undefined>;
-                            readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly test: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly phase: import("valibot").PicklistSchema<["testing", "fixing"], undefined>;
+                    readonly attempts: import("valibot").NumberSchema<undefined>;
+                    readonly maxAttempts: import("valibot").NumberSchema<undefined>;
+                    readonly lastReport: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                        readonly greenlight: import("valibot").BooleanSchema<undefined>;
+                        readonly summary: import("valibot").StringSchema<undefined>;
+                        readonly tested: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly outcomes: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                            readonly name: import("valibot").StringSchema<undefined>;
+                            readonly status: import("valibot").PicklistSchema<["passed", "failed", "skipped"], undefined>;
+                            readonly detail: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
                         }, undefined>, undefined>;
-                        readonly concerns: v.ArraySchema<v.ObjectSchema<{
-                            readonly title: v.StringSchema<undefined>;
-                            readonly detail: v.StringSchema<undefined>;
-                            readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
+                        readonly concerns: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                            readonly title: import("valibot").StringSchema<undefined>;
+                            readonly detail: import("valibot").StringSchema<undefined>;
+                            readonly severity: import("valibot").PicklistSchema<["low", "medium", "high", "critical"], undefined>;
                         }, undefined>, undefined>;
-                        readonly environment: v.OptionalSchema<v.PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
+                        readonly environment: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly humanTest: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly phase: v.PicklistSchema<["provisioning", "awaiting_human", "fixing", "resolving_conflicts", "passed"], undefined>;
-                    readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                        readonly id: v.StringSchema<undefined>;
-                        readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                        readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-                        readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
+                readonly humanTest: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly phase: import("valibot").PicklistSchema<["provisioning", "awaiting_human", "fixing", "resolving_conflicts", "passed"], undefined>;
+                    readonly environment: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly url: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly status: import("valibot").PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
+                        readonly expiresAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
                     }, undefined>, undefined>, undefined>;
-                    readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                    readonly attempts: v.NumberSchema<undefined>;
-                    readonly maxAttempts: v.NumberSchema<undefined>;
-                    readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                    readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly kind: v.PicklistSchema<["fix", "pull-main"], undefined>;
-                        readonly findings: v.StringSchema<undefined>;
-                        readonly helperKind: v.StringSchema<undefined>;
-                        readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                        readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-                        readonly at: v.NumberSchema<undefined>;
+                    readonly degradedReason: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly attempts: import("valibot").NumberSchema<undefined>;
+                    readonly maxAttempts: import("valibot").NumberSchema<undefined>;
+                    readonly headSha: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly rounds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly kind: import("valibot").PicklistSchema<["fix", "pull-main"], undefined>;
+                        readonly findings: import("valibot").StringSchema<undefined>;
+                        readonly helperKind: import("valibot").StringSchema<undefined>;
+                        readonly jobId: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly outcome: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
+                        readonly at: import("valibot").NumberSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
-                    readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                        readonly type: v.PicklistSchema<["confirm", "request-fix", "pull-main", "recreate"], undefined>;
-                        readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly pendingAction: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                        readonly type: import("valibot").PicklistSchema<["confirm", "request-fix", "pull-main", "recreate"], undefined>;
+                        readonly findings: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly id: v.StringSchema<undefined>;
-                    readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                    readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-                    readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                    readonly lastError: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly environment: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly url: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly status: import("valibot").PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
+                    readonly expiresAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly lastError: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly subtasks: v.OptionalSchema<v.ObjectSchema<{
-                    readonly completed: v.NumberSchema<undefined>;
-                    readonly inProgress: v.NumberSchema<undefined>;
-                    readonly total: v.NumberSchema<undefined>;
-                    readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly label: v.StringSchema<undefined>;
-                        readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
+                readonly subtasks: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                    readonly completed: import("valibot").NumberSchema<undefined>;
+                    readonly inProgress: import("valibot").NumberSchema<undefined>;
+                    readonly total: import("valibot").NumberSchema<undefined>;
+                    readonly items: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly label: import("valibot").StringSchema<undefined>;
+                        readonly status: import("valibot").PicklistSchema<["pending", "in_progress", "completed"], undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>;
-                readonly startingContainer: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly decision: v.NullableSchema<v.ObjectSchema<{
-                    readonly id: v.StringSchema<undefined>;
-                    readonly question: v.StringSchema<undefined>;
-                    readonly options: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-                    readonly chosen: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly startingContainer: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+                readonly decision: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly question: import("valibot").StringSchema<undefined>;
+                    readonly options: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly chosen: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                 }, undefined>, undefined>;
-                readonly requiresApproval: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly approval: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly id: v.StringSchema<undefined>;
-                    readonly status: v.PicklistSchema<["pending", "approved", "changes_requested", "rejected"], undefined>;
-                    readonly proposal: v.StringSchema<undefined>;
-                    readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                    readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                        readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                        readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                        readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                        readonly body: v.StringSchema<undefined>;
+                readonly requiresApproval: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+                readonly approval: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly status: import("valibot").PicklistSchema<["pending", "approved", "changes_requested", "rejected"], undefined>;
+                    readonly proposal: import("valibot").StringSchema<undefined>;
+                    readonly feedback: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly comments: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly quotedSource: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly srcStart: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        readonly srcEnd: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        readonly anchorId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly body: import("valibot").StringSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly companion: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly threshold: v.NumberSchema<undefined>;
-                    readonly maxAttempts: v.NumberSchema<undefined>;
-                    readonly attempts: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-                    readonly verdicts: v.ArraySchema<v.ObjectSchema<{
-                        readonly rating: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-                        readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-                        readonly passed: v.BooleanSchema<undefined>;
-                        readonly feedback: v.StringSchema<undefined>;
+                readonly companion: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly threshold: import("valibot").NumberSchema<undefined>;
+                    readonly maxAttempts: import("valibot").NumberSchema<undefined>;
+                    readonly attempts: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, 0>;
+                    readonly verdicts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly rating: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>;
+                        readonly threshold: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>;
+                        readonly passed: import("valibot").BooleanSchema<undefined>;
+                        readonly feedback: import("valibot").StringSchema<undefined>;
                     }, undefined>, undefined>;
-                    readonly exceeded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                    readonly exceeded: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly followUps: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly enabled: v.BooleanSchema<undefined>;
-                    readonly items: v.ArraySchema<v.ObjectSchema<{
-                        readonly id: v.StringSchema<undefined>;
-                        readonly kind: v.PicklistSchema<["follow_up", "question"], undefined>;
-                        readonly title: v.StringSchema<undefined>;
-                        readonly detail: v.StringSchema<undefined>;
-                        readonly suggestedAction: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                        readonly status: v.PicklistSchema<["pending", "filed", "queued", "answered", "dismissed"], undefined>;
-                        readonly answer: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                        readonly sentToCoder: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                        readonly ticketExternalId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                        readonly ticketUrl: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                        readonly createdAt: v.NumberSchema<undefined>;
-                        readonly updatedAt: v.NumberSchema<undefined>;
+                readonly followUps: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly enabled: import("valibot").BooleanSchema<undefined>;
+                    readonly items: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly kind: import("valibot").PicklistSchema<["follow_up", "question"], undefined>;
+                        readonly title: import("valibot").StringSchema<undefined>;
+                        readonly detail: import("valibot").StringSchema<undefined>;
+                        readonly suggestedAction: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly status: import("valibot").PicklistSchema<["pending", "filed", "queued", "answered", "dismissed"], undefined>;
+                        readonly answer: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly sentToCoder: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+                        readonly ticketExternalId: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly ticketUrl: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly createdAt: import("valibot").NumberSchema<undefined>;
+                        readonly updatedAt: import("valibot").NumberSchema<undefined>;
                     }, undefined>, undefined>;
-                    readonly loops: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-                    readonly maxLoops: v.OptionalSchema<v.NumberSchema<undefined>, 3>;
+                    readonly loops: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, 0>;
+                    readonly maxLoops: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, 3>;
                 }, undefined>, undefined>, undefined>;
-                readonly rework: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly previousProposal: v.StringSchema<undefined>;
-                    readonly feedback: v.StringSchema<undefined>;
-                    readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                        readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                        readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                        readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                        readonly body: v.StringSchema<undefined>;
+                readonly rework: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly previousProposal: import("valibot").StringSchema<undefined>;
+                    readonly feedback: import("valibot").StringSchema<undefined>;
+                    readonly comments: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly quotedSource: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly srcStart: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        readonly srcEnd: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        readonly anchorId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly body: import("valibot").StringSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly pendingIncorporation: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly pendingIncorporation: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly feedback: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly pendingRecommendation: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly itemIds: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-                    readonly note: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly pendingRecommendation: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly itemIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly note: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly consensus: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly enabled: v.BooleanSchema<undefined>;
-                    readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
-                    readonly participants: v.ArraySchema<v.ObjectSchema<{
-                        readonly id: v.StringSchema<undefined>;
-                        readonly role: v.StringSchema<undefined>;
-                        readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                        readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly consensus: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly enabled: import("valibot").BooleanSchema<undefined>;
+                    readonly strategy: import("valibot").PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+                    readonly participants: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly role: import("valibot").StringSchema<undefined>;
+                        readonly systemFraming: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly modelId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
                     }, undefined>, undefined>;
-                    readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                    readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
-                    readonly gating: v.OptionalSchema<v.ObjectSchema<{
-                        readonly enabled: v.BooleanSchema<undefined>;
-                        readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                        readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                        readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                        readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+                    readonly synthesizerModelId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly rounds: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 5, undefined>]>, undefined>;
+                    readonly gating: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                        readonly enabled: import("valibot").BooleanSchema<undefined>;
+                        readonly minComplexity: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>, undefined>;
+                        readonly minRisk: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>, undefined>;
+                        readonly minImpact: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>, undefined>;
+                        readonly onMissingEstimate: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
                     }, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
-                readonly gating: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly enabled: v.BooleanSchema<undefined>;
-                    readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                    readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                    readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                    readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+                readonly gating: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly enabled: import("valibot").BooleanSchema<undefined>;
+                    readonly minComplexity: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minRisk: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minImpact: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly onMissingEstimate: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["run", "skip"], undefined>, "run">;
                 }, undefined>, undefined>, undefined>;
-                readonly skipped: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly noBusinessSpecs: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly technicalCorroborated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly output: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly custom: v.OptionalSchema<v.UnknownSchema, undefined>;
-                readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly selectedFragmentIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly jobId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly startedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                readonly finishedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                readonly pausedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                readonly evictionRecoveries: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly transientEvictionRecoveries: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+                readonly skipped: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+                readonly noBusinessSpecs: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+                readonly technicalCorroborated: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+                readonly output: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly custom: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly model: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly selectedFragmentIds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly jobId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly startedAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly finishedAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly pausedAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly evictionRecoveries: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly transientEvictionRecoveries: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
             }, undefined>, undefined>;
-            readonly currentStep: v.NumberSchema<undefined>;
-            readonly status: v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
-            readonly failure: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly kind: v.PicklistSchema<["preflight", "dispatch", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "cancelled", "unknown"], undefined>;
-                readonly message: v.StringSchema<undefined>;
-                readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                readonly occurredAt: v.NumberSchema<undefined>;
-                readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
-                    readonly completed: v.NumberSchema<undefined>;
-                    readonly inProgress: v.NumberSchema<undefined>;
-                    readonly total: v.NumberSchema<undefined>;
-                    readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                        readonly label: v.StringSchema<undefined>;
-                        readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
+            readonly currentStep: import("valibot").NumberSchema<undefined>;
+            readonly status: import("valibot").PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
+            readonly failure: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").PicklistSchema<["preflight", "dispatch", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "cancelled", "unknown"], undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly detail: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly hint: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly occurredAt: import("valibot").NumberSchema<undefined>;
+                readonly lastSubtasks: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly completed: import("valibot").NumberSchema<undefined>;
+                    readonly inProgress: import("valibot").NumberSchema<undefined>;
+                    readonly total: import("valibot").NumberSchema<undefined>;
+                    readonly items: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly label: import("valibot").StringSchema<undefined>;
+                        readonly status: import("valibot").PicklistSchema<["pending", "in_progress", "completed"], undefined>;
                     }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>, undefined>, undefined>;
-            readonly initiatedBy: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly initiatedBy: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
         }, undefined>;
     };
 };

package/dist/routes/human-review.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"human-review.d.ts","sourceRoot":"","sources":["../../src/routes/human-review.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMxC,CAAA"}
+{"version":3,"file":"human-review.d.ts","sourceRoot":"","sources":["../../src/routes/human-review.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMxC,CAAA"}