@ztothez/design-engineering 2.0.0

package/dist/src/comparison/schema.d.ts

@@ -0,0 +1,464 @@
+import { z } from "zod";
+export declare const comparisonEvidenceLevelSchema: z.ZodEnum<{
+    automated: "automated";
+    "ai-assisted-expert": "ai-assisted-expert";
+    "human-expert": "human-expert";
+    "representative-user": "representative-user";
+}>;
+export declare const comparisonArtifactKindSchema: z.ZodEnum<{
+    export: "export";
+    screenshot: "screenshot";
+    "build-report": "build-report";
+    "typecheck-report": "typecheck-report";
+    "test-report": "test-report";
+    "static-audit": "static-audit";
+    "runtime-report": "runtime-report";
+    "journey-report": "journey-report";
+    "source-inspection": "source-inspection";
+    "human-review": "human-review";
+    "user-session": "user-session";
+}>;
+export declare const comparisonMethodologySchema: z.ZodObject<{
+    version: z.ZodEnum<{
+        "1.0": "1.0";
+        1.1: "1.1";
+    }>;
+    id: z.ZodString;
+    title: z.ZodString;
+    preparedAt: z.ZodString;
+    preparedBy: z.ZodObject<{
+        type: z.ZodEnum<{
+            agent: "agent";
+            human: "human";
+            mixed: "mixed";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    viewports: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strict>>;
+    states: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodBoolean;
+    }, z.core.$strict>>;
+    stages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodBoolean;
+        scope: z.ZodEnum<{
+            comparison: "comparison";
+            candidate: "candidate";
+        }>;
+        evidenceKinds: z.ZodArray<z.ZodEnum<{
+            export: "export";
+            screenshot: "screenshot";
+            "build-report": "build-report";
+            "typecheck-report": "typecheck-report";
+            "test-report": "test-report";
+            "static-audit": "static-audit";
+            "runtime-report": "runtime-report";
+            "journey-report": "journey-report";
+            "source-inspection": "source-inspection";
+            "human-review": "human-review";
+            "user-session": "user-session";
+        }>>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        successCriteria: z.ZodArray<z.ZodString>;
+        measurements: z.ZodArray<z.ZodEnum<{
+            "task-completion": "task-completion";
+            "time-on-task": "time-on-task";
+            "navigation-errors": "navigation-errors";
+            "comprehension-accuracy": "comprehension-accuracy";
+            "recovery-attempts": "recovery-attempts";
+            confidence: "confidence";
+            "perceived-visual-quality": "perceived-visual-quality";
+        }>>;
+    }, z.core.$strict>>;
+    rubric: z.ZodObject<{
+        scale: z.ZodObject<{
+            minimum: z.ZodLiteral<0>;
+            maximum: z.ZodLiteral<4>;
+            anchors: z.ZodRecord<z.ZodEnum<{
+                0: "0";
+                1: "1";
+                2: "2";
+                3: "3";
+                4: "4";
+            }>, z.ZodString>;
+        }, z.core.$strict>;
+        categories: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            weight: z.ZodNumber;
+            criteria: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                prompt: z.ZodString;
+                measurement: z.ZodEnum<{
+                    rating: "rating";
+                    comprehension: "comprehension";
+                    "task-observation": "task-observation";
+                }>;
+                evidenceLevel: z.ZodEnum<{
+                    "human-expert": "human-expert";
+                    "representative-user": "representative-user";
+                }>;
+                scoreMinimum: z.ZodLiteral<0>;
+                scoreMaximum: z.ZodLiteral<4>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evidencePolicy: z.ZodObject<{
+        anonymizeCandidates: z.ZodLiteral<true>;
+        counterbalanceOrder: z.ZodLiteral<true>;
+        retainArtifacts: z.ZodLiteral<true>;
+        separateEvidenceLevels: z.ZodLiteral<true>;
+        requireHumanAttribution: z.ZodLiteral<true>;
+        prohibitAgentHumanAttestation: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        minimumCategoryScore: z.ZodNumber;
+        requireAllStagesPass: z.ZodBoolean;
+        prohibitContradictedClaims: z.ZodBoolean;
+        requiredEvidenceLevels: z.ZodArray<z.ZodEnum<{
+            automated: "automated";
+            "ai-assisted-expert": "ai-assisted-expert";
+            "human-expert": "human-expert";
+            "representative-user": "representative-user";
+        }>>;
+        requiredStageCandidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        reviewRequirements: z.ZodOptional<z.ZodObject<{
+            minimumHumanExpertSessions: z.ZodNumber;
+            minimumRepresentativeUserSessions: z.ZodNumber;
+            requireCompleteTaskMatrix: z.ZodBoolean;
+            requireCompleteRatingMatrix: z.ZodBoolean;
+            requireIdentityBlinding: z.ZodBoolean;
+            minimumCounterbalancedOrders: z.ZodNumber;
+        }, z.core.$strict>>;
+        benchmark: z.ZodOptional<z.ZodObject<{
+            targetCandidate: z.ZodString;
+            comparatorCandidates: z.ZodArray<z.ZodString>;
+            requiredCategoryIds: z.ZodArray<z.ZodString>;
+            requireTaskMetricNonRegression: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const comparisonReviewSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    level: z.ZodEnum<{
+        "ai-assisted-expert": "ai-assisted-expert";
+        "human-expert": "human-expert";
+        "representative-user": "representative-user";
+    }>;
+    origin: z.ZodEnum<{
+        "agent-generated": "agent-generated";
+        "reviewer-supplied": "reviewer-supplied";
+    }>;
+    contributor: z.ZodOptional<z.ZodString>;
+    recordedAt: z.ZodOptional<z.ZodString>;
+    participantId: z.ZodOptional<z.ZodString>;
+    blinding: z.ZodOptional<z.ZodObject<{
+        candidateIdentitiesWithheld: z.ZodBoolean;
+        priorCandidateExposure: z.ZodBoolean;
+        conflicts: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    candidateOrder: z.ZodArray<z.ZodString>;
+    taskResults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        task: z.ZodString;
+        candidate: z.ZodString;
+        outcome: z.ZodEnum<{
+            partial: "partial";
+            failed: "failed";
+            completed: "completed";
+            "not-run": "not-run";
+        }>;
+        durationSeconds: z.ZodOptional<z.ZodNumber>;
+        navigationErrors: z.ZodNumber;
+        recoveryAttempts: z.ZodNumber;
+        comprehensionCorrect: z.ZodOptional<z.ZodBoolean>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    ratings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        candidate: z.ZodString;
+        criterion: z.ZodString;
+        score: z.ZodNumber;
+        rationale: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const comparisonReviewSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    methodologyId: z.ZodString;
+    preparedAt: z.ZodString;
+    preparedBy: z.ZodObject<{
+        type: z.ZodEnum<{
+            agent: "agent";
+            human: "human";
+            mixed: "mixed";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    candidates: z.ZodArray<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        candidate: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"comparison">]>;
+        stage: z.ZodString;
+        kind: z.ZodEnum<{
+            export: "export";
+            screenshot: "screenshot";
+            "build-report": "build-report";
+            "typecheck-report": "typecheck-report";
+            "test-report": "test-report";
+            "static-audit": "static-audit";
+            "runtime-report": "runtime-report";
+            "journey-report": "journey-report";
+            "source-inspection": "source-inspection";
+            "human-review": "human-review";
+            "user-session": "user-session";
+        }>;
+        path: z.ZodString;
+        producer: z.ZodEnum<{
+            agent: "agent";
+            human: "human";
+            automation: "automation";
+        }>;
+        retained: z.ZodBoolean;
+        scope: z.ZodString;
+        recordedAt: z.ZodString;
+        sourceRevision: z.ZodString;
+        sha256: z.ZodString;
+        capture: z.ZodOptional<z.ZodObject<{
+            viewport: z.ZodString;
+            state: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+        accessibility: z.ZodOptional<z.ZodObject<{
+            standard: z.ZodLiteral<"WCAG">;
+            version: z.ZodEnum<{
+                2.1: "2.1";
+                2.2: "2.2";
+            }>;
+            level: z.ZodEnum<{
+                A: "A";
+                AA: "AA";
+                AAA: "AAA";
+            }>;
+            coverage: z.ZodEnum<{
+                "sampled-states": "sampled-states";
+                "declared-routes": "declared-routes";
+                "full-product": "full-product";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    stages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        candidate: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"comparison">]>;
+        status: z.ZodEnum<{
+            partial: "partial";
+            pass: "pass";
+            fail: "fail";
+            "not-run": "not-run";
+        }>;
+        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        level: z.ZodEnum<{
+            "ai-assisted-expert": "ai-assisted-expert";
+            "human-expert": "human-expert";
+            "representative-user": "representative-user";
+        }>;
+        origin: z.ZodEnum<{
+            "agent-generated": "agent-generated";
+            "reviewer-supplied": "reviewer-supplied";
+        }>;
+        contributor: z.ZodOptional<z.ZodString>;
+        recordedAt: z.ZodOptional<z.ZodString>;
+        participantId: z.ZodOptional<z.ZodString>;
+        blinding: z.ZodOptional<z.ZodObject<{
+            candidateIdentitiesWithheld: z.ZodBoolean;
+            priorCandidateExposure: z.ZodBoolean;
+            conflicts: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        candidateOrder: z.ZodArray<z.ZodString>;
+        taskResults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            candidate: z.ZodString;
+            outcome: z.ZodEnum<{
+                partial: "partial";
+                failed: "failed";
+                completed: "completed";
+                "not-run": "not-run";
+            }>;
+            durationSeconds: z.ZodOptional<z.ZodNumber>;
+            navigationErrors: z.ZodNumber;
+            recoveryAttempts: z.ZodNumber;
+            comprehensionCorrect: z.ZodOptional<z.ZodBoolean>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        ratings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            candidate: z.ZodString;
+            criterion: z.ZodString;
+            score: z.ZodNumber;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    claims: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        candidate: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"comparison">]>;
+        kind: z.ZodEnum<{
+            "overall-result": "overall-result";
+            "stage-result": "stage-result";
+            "accessibility-conformance": "accessibility-conformance";
+            "design-quality": "design-quality";
+            "implementation-fact": "implementation-fact";
+        }>;
+        statement: z.ZodString;
+        evidenceType: z.ZodEnum<{
+            automated: "automated";
+            "ai-assisted-expert": "ai-assisted-expert";
+            "human-expert": "human-expert";
+            "representative-user": "representative-user";
+        }>;
+        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        sessionRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        scope: z.ZodString;
+        status: z.ZodEnum<{
+            partial: "partial";
+            unverified: "unverified";
+            verified: "verified";
+            contradicted: "contradicted";
+        }>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            partial: "partial";
+            pass: "pass";
+            fail: "fail";
+            "not-evaluated": "not-evaluated";
+        }>>;
+        limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        accessibility: z.ZodOptional<z.ZodObject<{
+            standard: z.ZodLiteral<"WCAG">;
+            version: z.ZodEnum<{
+                2.1: "2.1";
+                2.2: "2.2";
+            }>;
+            level: z.ZodEnum<{
+                A: "A";
+                AA: "AA";
+                AAA: "AAA";
+            }>;
+            coverage: z.ZodEnum<{
+                "sampled-states": "sampled-states";
+                "declared-routes": "declared-routes";
+                "full-product": "full-product";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const comparisonFindingSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+        info: "info";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+    remediation: z.ZodString;
+}, z.core.$strict>;
+export declare const comparisonReportSchema: z.ZodObject<{
+    version: z.ZodString;
+    generatedAt: z.ZodString;
+    methodologyPath: z.ZodString;
+    reviewPath: z.ZodString;
+    methodologyId: z.ZodString;
+    reviewId: z.ZodString;
+    passed: z.ZodBoolean;
+    releaseReady: z.ZodBoolean;
+    findings: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        remediation: z.ZodString;
+    }, z.core.$strict>>;
+    summary: z.ZodObject<{
+        errors: z.ZodNumber;
+        warnings: z.ZodNumber;
+        info: z.ZodNumber;
+        requiredStages: z.ZodNumber;
+        passedRequiredStages: z.ZodNumber;
+        claims: z.ZodNumber;
+        verifiedClaims: z.ZodNumber;
+        sessions: z.ZodNumber;
+    }, z.core.$strict>;
+    stageResults: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        candidate: z.ZodString;
+        required: z.ZodBoolean;
+        status: z.ZodString;
+    }, z.core.$strict>>;
+    evidenceLevels: z.ZodObject<{
+        automated: z.ZodNumber;
+        aiAssistedExpert: z.ZodNumber;
+        humanExpert: z.ZodNumber;
+        representativeUser: z.ZodNumber;
+    }, z.core.$strict>;
+    humanReview: z.ZodObject<{
+        requirementsConfigured: z.ZodBoolean;
+        humanExpertSessions: z.ZodNumber;
+        representativeUserSessions: z.ZodNumber;
+        completeHumanExpertSessions: z.ZodNumber;
+        completeRepresentativeUserSessions: z.ZodNumber;
+        distinctCandidateOrders: z.ZodNumber;
+        blindedReviewerSessions: z.ZodNumber;
+        minimumHumanExpertSessions: z.ZodNumber;
+        minimumRepresentativeUserSessions: z.ZodNumber;
+        minimumCounterbalancedOrders: z.ZodNumber;
+        requirementsMet: z.ZodBoolean;
+    }, z.core.$strict>;
+    candidateResults: z.ZodArray<z.ZodObject<{
+        candidate: z.ZodString;
+        categories: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            score: z.ZodNullable<z.ZodNumber>;
+            samples: z.ZodNumber;
+        }, z.core.$strict>>;
+        tasks: z.ZodObject<{
+            samples: z.ZodNumber;
+            completionRate: z.ZodNullable<z.ZodNumber>;
+            comprehensionAccuracy: z.ZodNullable<z.ZodNumber>;
+            meanDurationSeconds: z.ZodNullable<z.ZodNumber>;
+            meanConfidence: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    benchmarkDecision: z.ZodObject<{
+        configured: z.ZodBoolean;
+        targetCandidate: z.ZodNullable<z.ZodString>;
+        comparatorCandidates: z.ZodArray<z.ZodString>;
+        passed: z.ZodBoolean;
+        issues: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ComparisonMethodology = z.infer<typeof comparisonMethodologySchema>;
+export type ComparisonReview = z.infer<typeof comparisonReviewSchema>;
+export type ComparisonFinding = z.infer<typeof comparisonFindingSchema>;
+export type ComparisonReport = z.infer<typeof comparisonReportSchema>;
+export type ComparisonEvidenceLevel = z.infer<typeof comparisonEvidenceLevelSchema>;
+export type ComparisonReviewSession = z.infer<typeof comparisonReviewSessionSchema>;