@ztothez/design-engineering 2.0.0

package/dist/src/design-intelligence/schema.d.ts

@@ -0,0 +1,838 @@
+import { z } from "zod";
+export declare const deliverableKindSchema: z.ZodEnum<{
+    "interface-system": "interface-system";
+    "brand-system": "brand-system";
+    "figma-library": "figma-library";
+    "asset-set": "asset-set";
+    "icon-system": "icon-system";
+    presentation: "presentation";
+}>;
+export declare const generationStageSchema: z.ZodEnum<{
+    "product-task": "product-task";
+    "truth-data-source-contract": "truth-data-source-contract";
+    "information-architecture": "information-architecture";
+    "interaction-state-model": "interaction-state-model";
+    "visual-direction": "visual-direction";
+    "token-architecture": "token-architecture";
+    implementation: "implementation";
+    "automated-verification": "automated-verification";
+    "human-visual-review": "human-visual-review";
+}>;
+export declare const designDeliverableSchema: z.ZodObject<{
+    version: z.ZodEnum<{
+        "1.0": "1.0";
+        2.1: "2.1";
+        "2.0": "2.0";
+    }>;
+    id: z.ZodString;
+    product: z.ZodString;
+    preparedAt: z.ZodString;
+    preparedBy: z.ZodObject<{
+        type: z.ZodEnum<{
+            agent: "agent";
+            human: "human";
+            mixed: "mixed";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        deliverables: z.ZodArray<z.ZodEnum<{
+            "interface-system": "interface-system";
+            "brand-system": "brand-system";
+            "figma-library": "figma-library";
+            "asset-set": "asset-set";
+            "icon-system": "icon-system";
+            presentation: "presentation";
+        }>>;
+        audience: z.ZodString;
+        channels: z.ZodArray<z.ZodEnum<{
+            desktop: "desktop";
+            presentation: "presentation";
+            web: "web";
+            mobile: "mobile";
+            print: "print";
+            social: "social";
+        }>>;
+    }, z.core.$strict>;
+    tokenSystem: z.ZodObject<{
+        tokens: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                number: "number";
+                duration: "duration";
+                dimension: "dimension";
+                color: "color";
+                "font-family": "font-family";
+                "font-weight": "font-weight";
+                shadow: "shadow";
+            }>;
+            level: z.ZodEnum<{
+                component: "component";
+                primitive: "primitive";
+                semantic: "semantic";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            reference: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            overrides: z.ZodArray<z.ZodObject<{
+                token: z.ZodString;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                reference: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    productTask: z.ZodOptional<z.ZodObject<{
+        productContractId: z.ZodString;
+        contractPath: z.ZodString;
+        primaryUser: z.ZodString;
+        task: z.ZodString;
+        successCriteria: z.ZodArray<z.ZodString>;
+        consequentialActions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    interfaceTrust: z.ZodOptional<z.ZodObject<{
+        contractId: z.ZodString;
+        contractPath: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+        status: z.ZodEnum<{
+            declared: "declared";
+            validated: "validated";
+        }>;
+        requiredScenarios: z.ZodArray<z.ZodEnum<{
+            disconnected: "disconnected";
+            stale: "stale";
+            fallback: "fallback";
+            demo: "demo";
+            live: "live";
+        }>>;
+        reportPath: z.ZodOptional<z.ZodString>;
+        evidenceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    informationHierarchy: z.ZodOptional<z.ZodObject<{
+        contractId: z.ZodString;
+        contractPath: z.ZodString;
+        version: z.ZodLiteral<"1.0">;
+        status: z.ZodEnum<{
+            declared: "declared";
+            validated: "validated";
+        }>;
+        levels: z.ZodArray<z.ZodEnum<{
+            "context-provenance": "context-provenance";
+            "primary-outcome-action": "primary-outcome-action";
+            "critical-exceptions": "critical-exceptions";
+            "health-impact-metrics": "health-impact-metrics";
+            "prioritized-findings": "prioritized-findings";
+            "operational-telemetry": "operational-telemetry";
+            "evidence-audit-trail": "evidence-audit-trail";
+            "history-exports": "history-exports";
+        }>>;
+        reportPath: z.ZodOptional<z.ZodString>;
+        evidenceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    metricContracts: z.ZodOptional<z.ZodObject<{
+        informationContractId: z.ZodString;
+        metrics: z.ZodArray<z.ZodObject<{
+            metricId: z.ZodString;
+            decision: z.ZodString;
+            hierarchyLevel: z.ZodEnum<{
+                "primary-outcome-action": "primary-outcome-action";
+                "health-impact-metrics": "health-impact-metrics";
+                "operational-telemetry": "operational-telemetry";
+            }>;
+            chartRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    generationWorkflow: z.ZodOptional<z.ZodObject<{
+        steps: z.ZodArray<z.ZodObject<{
+            stage: z.ZodEnum<{
+                "product-task": "product-task";
+                "truth-data-source-contract": "truth-data-source-contract";
+                "information-architecture": "information-architecture";
+                "interaction-state-model": "interaction-state-model";
+                "visual-direction": "visual-direction";
+                "token-architecture": "token-architecture";
+                implementation: "implementation";
+                "automated-verification": "automated-verification";
+                "human-visual-review": "human-visual-review";
+            }>;
+            status: z.ZodEnum<{
+                required: "required";
+                verified: "verified";
+                declared: "declared";
+                implemented: "implemented";
+                "review-required": "review-required";
+                "review-completed": "review-completed";
+            }>;
+            artifactRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    visualDirection: z.ZodOptional<z.ZodObject<{
+        domain: z.ZodString;
+        intent: z.ZodString;
+        principles: z.ZodArray<z.ZodString>;
+        avoid: z.ZodArray<z.ZodString>;
+        tokenRefs: z.ZodArray<z.ZodString>;
+        ornamentPolicy: z.ZodObject<{
+            decorativeAgentDiagrams: z.ZodLiteral<false>;
+            excessiveGlow: z.ZodLiteral<false>;
+            meaninglessGradients: z.ZodLiteral<false>;
+            ornamentalStatusElements: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        referenceEvidenceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    typography: z.ZodOptional<z.ZodObject<{
+        minimumBodySizePx: z.ZodNumber;
+        maximumLineLengthCharacters: z.ZodNumber;
+        numericAlignment: z.ZodEnum<{
+            tabular: "tabular";
+            proportional: "proportional";
+        }>;
+        roles: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                label: "label";
+                code: "code";
+                evidence: "evidence";
+                body: "body";
+                heading: "heading";
+                metadata: "metadata";
+                metric: "metric";
+                log: "log";
+            }>;
+            familyToken: z.ZodString;
+            sizeToken: z.ZodString;
+            weightToken: z.ZodString;
+            lineHeightToken: z.ZodString;
+            colorToken: z.ZodString;
+            usage: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    composition: z.ZodOptional<z.ZodObject<{
+        contentWidth: z.ZodObject<{
+            strategy: z.ZodEnum<{
+                fluid: "fluid";
+                bounded: "bounded";
+                hybrid: "hybrid";
+            }>;
+            maximumPx: z.ZodNumber;
+        }, z.core.$strict>;
+        grids: z.ZodArray<z.ZodObject<{
+            viewport: z.ZodUnion<readonly [z.ZodLiteral<375>, z.ZodLiteral<768>, z.ZodLiteral<1024>, z.ZodLiteral<1440>]>;
+            columns: z.ZodNumber;
+            gutterToken: z.ZodString;
+            marginToken: z.ZodString;
+            composition: z.ZodString;
+        }, z.core.$strict>>;
+        spacingRhythm: z.ZodObject<{
+            baseToken: z.ZodString;
+            allowedStepTokens: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        alignmentRules: z.ZodArray<z.ZodString>;
+        stableDimensions: z.ZodArray<z.ZodObject<{
+            component: z.ZodString;
+            behavior: z.ZodEnum<{
+                fixed: "fixed";
+                bounded: "bounded";
+                "aspect-ratio": "aspect-ratio";
+            }>;
+            tokenRefs: z.ZodArray<z.ZodString>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>;
+        surfaces: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                canvas: "canvas";
+                subtle: "subtle";
+                raised: "raised";
+                overlay: "overlay";
+                inverse: "inverse";
+            }>;
+            tokenRef: z.ZodString;
+        }, z.core.$strict>>;
+        borders: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                default: "default";
+                strong: "strong";
+                focus: "focus";
+                selected: "selected";
+            }>;
+            tokenRef: z.ZodString;
+        }, z.core.$strict>>;
+        elevations: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                raised: "raised";
+                overlay: "overlay";
+                base: "base";
+            }>;
+            tokenRef: z.ZodString;
+        }, z.core.$strict>>;
+        emphasis: z.ZodArray<z.ZodObject<{
+            level: z.ZodEnum<{
+                primary: "primary";
+                secondary: "secondary";
+                tertiary: "tertiary";
+                muted: "muted";
+            }>;
+            textToken: z.ZodString;
+            surfaceToken: z.ZodString;
+        }, z.core.$strict>>;
+        selectedState: z.ZodObject<{
+            backgroundToken: z.ZodString;
+            borderToken: z.ZodString;
+            indicator: z.ZodString;
+            nonColorCue: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    densityProfile: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            comfortable: "comfortable";
+            compact: "compact";
+            dense: "dense";
+            adaptive: "adaptive";
+        }>;
+        rationale: z.ZodString;
+        controlHeightToken: z.ZodString;
+        rowHeightToken: z.ZodString;
+        compactRowHeightToken: z.ZodString;
+        spacingTokenRefs: z.ZodArray<z.ZodString>;
+        maximumPrimaryActions: z.ZodNumber;
+        viewportBehavior: z.ZodArray<z.ZodObject<{
+            viewport: z.ZodUnion<readonly [z.ZodLiteral<375>, z.ZodLiteral<768>, z.ZodLiteral<1024>, z.ZodLiteral<1440>]>;
+            mode: z.ZodEnum<{
+                comfortable: "comfortable";
+                compact: "compact";
+                dense: "dense";
+            }>;
+            visiblePriorities: z.ZodArray<z.ZodString>;
+            priorityRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                findings: "findings";
+                evidence: "evidence";
+                "critical-exceptions": "critical-exceptions";
+                context: "context";
+                "primary-outcome": "primary-outcome";
+                impact: "impact";
+                "next-action": "next-action";
+                "supporting-metrics": "supporting-metrics";
+                telemetry: "telemetry";
+                history: "history";
+            }>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    interactionStates: z.ZodOptional<z.ZodObject<{
+        states: z.ZodArray<z.ZodObject<{
+            state: z.ZodEnum<{
+                error: "error";
+                warning: "warning";
+                disabled: "disabled";
+                success: "success";
+                loading: "loading";
+                empty: "empty";
+                partial: "partial";
+                focus: "focus";
+                selected: "selected";
+            }>;
+            behavior: z.ZodString;
+            tokenRefs: z.ZodArray<z.ZodString>;
+            textCue: z.ZodBoolean;
+            iconCue: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    motion: z.ZodOptional<z.ZodObject<{
+        durationTokens: z.ZodObject<{
+            instant: z.ZodString;
+            feedback: z.ZodString;
+            transition: z.ZodString;
+            emphasis: z.ZodString;
+        }, z.core.$strict>;
+        motions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            purpose: z.ZodString;
+            trigger: z.ZodString;
+            property: z.ZodEnum<{
+                transform: "transform";
+                opacity: "opacity";
+                color: "color";
+                size: "size";
+                position: "position";
+                progress: "progress";
+            }>;
+            durationCategory: z.ZodEnum<{
+                transition: "transition";
+                emphasis: "emphasis";
+                instant: "instant";
+                feedback: "feedback";
+            }>;
+            interruptible: z.ZodBoolean;
+        }, z.core.$strict>>;
+        reducedMotion: z.ZodObject<{
+            strategy: z.ZodEnum<{
+                replace: "replace";
+                remove: "remove";
+                shorten: "shorten";
+            }>;
+            equivalents: z.ZodArray<z.ZodObject<{
+                motionRef: z.ZodString;
+                behavior: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    chartContracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        purpose: z.ZodString;
+        type: z.ZodEnum<{
+            bar: "bar";
+            line: "line";
+            area: "area";
+            scatter: "scatter";
+            distribution: "distribution";
+            timeline: "timeline";
+            "table-first": "table-first";
+        }>;
+        metricRefs: z.ZodArray<z.ZodString>;
+        labelStrategy: z.ZodEnum<{
+            "table-first": "table-first";
+            direct: "direct";
+            "axis-and-legend": "axis-and-legend";
+        }>;
+        titleVisible: z.ZodBoolean;
+        valuesVisible: z.ZodBoolean;
+        legend: z.ZodObject<{
+            visible: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        comparison: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            context: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"not-applicable">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "status">;
+        alternative: z.ZodObject<{
+            kind: z.ZodEnum<{
+                text: "text";
+                table: "table";
+            }>;
+            path: z.ZodString;
+        }, z.core.$strict>;
+        states: z.ZodObject<{
+            loading: z.ZodString;
+            empty: z.ZodString;
+            partial: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>;
+        tokenRefs: z.ZodArray<z.ZodString>;
+        backgroundToken: z.ZodOptional<z.ZodString>;
+        nonColorCues: z.ZodArray<z.ZodEnum<{
+            value: "value";
+            pattern: "pattern";
+            text: "text";
+            color: "color";
+            position: "position";
+            icon: "icon";
+            shape: "shape";
+            "line-style": "line-style";
+        }>>;
+        decorative: z.ZodLiteral<false>;
+    }, z.core.$strict>>>;
+    renderedEvidence: z.ZodOptional<z.ZodObject<{
+        fixture: z.ZodObject<{
+            id: z.ZodString;
+            sourcePath: z.ZodString;
+            route: z.ZodString;
+        }, z.core.$strict>;
+        captures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            viewport: z.ZodUnion<readonly [z.ZodLiteral<375>, z.ZodLiteral<768>, z.ZodLiteral<1024>, z.ZodLiteral<1440>]>;
+            status: z.ZodLiteral<"planned">;
+        }, z.core.$strict>, z.ZodObject<{
+            viewport: z.ZodUnion<readonly [z.ZodLiteral<375>, z.ZodLiteral<768>, z.ZodLiteral<1024>, z.ZodLiteral<1440>]>;
+            status: z.ZodEnum<{
+                verified: "verified";
+                captured: "captured";
+            }>;
+            screenshotPath: z.ZodString;
+            runtimeReportPath: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>], "status">>;
+    }, z.core.$strict>>;
+    humanVisualReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            required: "required";
+            completed: "completed";
+        }>;
+        dimensions: z.ZodArray<z.ZodEnum<{
+            hierarchy: "hierarchy";
+            balance: "balance";
+            scanability: "scanability";
+            density: "density";
+            "domain-fit": "domain-fit";
+        }>>;
+        reviewers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+            reviewedAt: z.ZodString;
+            evidenceRef: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    brand: z.ZodOptional<z.ZodObject<{
+        promise: z.ZodString;
+        audiences: z.ZodArray<z.ZodString>;
+        attributes: z.ZodArray<z.ZodString>;
+        avoid: z.ZodArray<z.ZodString>;
+        voicePrinciples: z.ZodArray<z.ZodString>;
+        marks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                symbol: "symbol";
+                primary: "primary";
+                compact: "compact";
+                monochrome: "monochrome";
+                wordmark: "wordmark";
+            }>;
+            asset: z.ZodString;
+            clearSpace: z.ZodString;
+            minimumSize: z.ZodString;
+            allowedBackgrounds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    figma: z.ZodOptional<z.ZodObject<{
+        pages: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodEnum<{
+                archive: "archive";
+                patterns: "patterns";
+                cover: "cover";
+                foundations: "foundations";
+                components: "components";
+                templates: "templates";
+                sandbox: "sandbox";
+            }>;
+            purpose: z.ZodString;
+        }, z.core.$strict>>;
+        collections: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            modes: z.ZodArray<z.ZodString>;
+            tokens: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        components: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            purpose: z.ZodString;
+            interactive: z.ZodBoolean;
+            properties: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    boolean: "boolean";
+                    text: "text";
+                    "instance-swap": "instance-swap";
+                    variant: "variant";
+                    slot: "slot";
+                }>;
+            }, z.core.$strict>>;
+            states: z.ZodArray<z.ZodString>;
+            documented: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    assets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        purpose: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            screenshot: "screenshot";
+            icon: "icon";
+            logo: "logo";
+            illustration: "illustration";
+            photo: "photo";
+            texture: "texture";
+            chart: "chart";
+            video: "video";
+            audio: "audio";
+            font: "font";
+        }>;
+        path: z.ZodString;
+        source: z.ZodObject<{
+            origin: z.ZodEnum<{
+                original: "original";
+                "user-provided": "user-provided";
+                generated: "generated";
+                commissioned: "commissioned";
+                licensed: "licensed";
+                "open-source": "open-source";
+                "public-domain": "public-domain";
+            }>;
+            creator: z.ZodString;
+            sourceUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        rights: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                approved: "approved";
+                pending: "pending";
+                rejected: "rejected";
+            }>;
+            basis: z.ZodEnum<{
+                contract: "contract";
+                "public-domain": "public-domain";
+                owned: "owned";
+                "terms-of-service": "terms-of-service";
+                "spdx-license": "spdx-license";
+                permission: "permission";
+            }>;
+            spdxExpression: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodOptional<z.ZodString>;
+            attribution: z.ZodOptional<z.ZodString>;
+            restrictions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            reviewedBy: z.ZodOptional<z.ZodString>;
+            reviewedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        generation: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            promptRecord: z.ZodString;
+            humanContributions: z.ZodArray<z.ZodString>;
+            references: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                rightsStatus: z.ZodEnum<{
+                    unknown: "unknown";
+                    approved: "approved";
+                    pending: "pending";
+                    rejected: "rejected";
+                }>;
+                evidence: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        alternative: z.ZodObject<{
+            kind: z.ZodEnum<{
+                decorative: "decorative";
+                "short-text": "short-text";
+                "long-description": "long-description";
+                "data-table": "data-table";
+                caption: "caption";
+                transcript: "transcript";
+            }>;
+            content: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        failureBehavior: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<{
+                "hide-decorative": "hide-decorative";
+                "text-alternative": "text-alternative";
+                placeholder: "placeholder";
+                retry: "retry";
+                block: "block";
+            }>;
+            behavior: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    iconSystem: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        grid: z.ZodNumber;
+        sizes: z.ZodArray<z.ZodNumber>;
+        stroke: z.ZodObject<{
+            style: z.ZodEnum<{
+                mixed: "mixed";
+                outline: "outline";
+                filled: "filled";
+                duotone: "duotone";
+            }>;
+            weight: z.ZodNumber;
+            linecap: z.ZodEnum<{
+                round: "round";
+                square: "square";
+                butt: "butt";
+            }>;
+            linejoin: z.ZodEnum<{
+                round: "round";
+                bevel: "bevel";
+                miter: "miter";
+            }>;
+        }, z.core.$strict>;
+        icons: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            meaning: z.ZodString;
+            asset: z.ZodString;
+            decorative: z.ZodBoolean;
+            accessibleName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    presentations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        purpose: z.ZodString;
+        audience: z.ZodString;
+        aspectRatio: z.ZodEnum<{
+            "16:9": "16:9";
+            "4:3": "4:3";
+            "1:1": "1:1";
+            "a4-landscape": "a4-landscape";
+            "a4-portrait": "a4-portrait";
+        }>;
+        masterLayouts: z.ZodArray<z.ZodString>;
+        slides: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            purpose: z.ZodString;
+            layout: z.ZodString;
+            readingOrder: z.ZodArray<z.ZodString>;
+            assets: z.ZodArray<z.ZodString>;
+            speakerNotes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    accessibility: z.ZodObject<{
+        contrastPairs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            foreground: z.ZodString;
+            background: z.ZodString;
+            usage: z.ZodEnum<{
+                "normal-text": "normal-text";
+                "large-text": "large-text";
+                "non-text": "non-text";
+            }>;
+            mode: z.ZodOptional<z.ZodString>;
+            fontSizePx: z.ZodOptional<z.ZodNumber>;
+            fontWeight: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        nonColorCues: z.ZodArray<z.ZodObject<{
+            meaning: z.ZodString;
+            cues: z.ZodArray<z.ZodEnum<{
+                value: "value";
+                pattern: "pattern";
+                text: "text";
+                color: "color";
+                position: "position";
+                icon: "icon";
+                shape: "shape";
+                underline: "underline";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            export: "export";
+            runtime: "runtime";
+            source: "source";
+            license: "license";
+            review: "review";
+            contrast: "contrast";
+        }>;
+        path: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const designIntelligenceFindingSchema: 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 designDeliverableReportSchema: z.ZodObject<{
+    version: z.ZodString;
+    generatedAt: z.ZodString;
+    sourcePath: z.ZodString;
+    manifestId: z.ZodString;
+    product: z.ZodString;
+    deliverables: z.ZodArray<z.ZodEnum<{
+        "interface-system": "interface-system";
+        "brand-system": "brand-system";
+        "figma-library": "figma-library";
+        "asset-set": "asset-set";
+        "icon-system": "icon-system";
+        presentation: "presentation";
+    }>>;
+    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>>;
+    contrastResults: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ratio: z.ZodNumber;
+        required: z.ZodNumber;
+        passed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    coverage: z.ZodObject<{
+        tokens: z.ZodNumber;
+        assets: z.ZodNumber;
+        icons: z.ZodNumber;
+        presentations: z.ZodNumber;
+        slides: z.ZodNumber;
+        contrastPairs: z.ZodNumber;
+        typographyRoles: z.ZodNumber;
+        interactionStates: z.ZodNumber;
+        chartContracts: z.ZodNumber;
+        renderedViewports: z.ZodNumber;
+        metricContracts: z.ZodNumber;
+        generationStages: z.ZodNumber;
+    }, z.core.$strict>;
+    integration: z.ZodObject<{
+        generationReady: z.ZodBoolean;
+        trustStatus: z.ZodEnum<{
+            missing: "missing";
+            declared: "declared";
+            validated: "validated";
+        }>;
+        informationStatus: z.ZodEnum<{
+            missing: "missing";
+            declared: "declared";
+            validated: "validated";
+        }>;
+        contractsValidated: z.ZodBoolean;
+        automatedVerificationReady: z.ZodBoolean;
+        humanReviewReady: z.ZodBoolean;
+        releaseReady: z.ZodBoolean;
+        stages: z.ZodRecord<z.ZodEnum<{
+            "product-task": "product-task";
+            "truth-data-source-contract": "truth-data-source-contract";
+            "information-architecture": "information-architecture";
+            "interaction-state-model": "interaction-state-model";
+            "visual-direction": "visual-direction";
+            "token-architecture": "token-architecture";
+            implementation: "implementation";
+            "automated-verification": "automated-verification";
+            "human-visual-review": "human-visual-review";
+        }>, z.ZodEnum<{
+            required: "required";
+            missing: "missing";
+            verified: "verified";
+            declared: "declared";
+            implemented: "implemented";
+            "review-required": "review-required";
+            "review-completed": "review-completed";
+        }>>;
+    }, z.core.$strict>;
+    visualPolish: z.ZodObject<{
+        declared: z.ZodBoolean;
+        requiredViewports: z.ZodRecord<z.ZodEnum<{
+            375: "375";
+            768: "768";
+            1024: "1024";
+            1440: "1440";
+        }>, z.ZodEnum<{
+            missing: "missing";
+            verified: "verified";
+            planned: "planned";
+            captured: "captured";
+        }>>;
+        renderedEvidenceReady: z.ZodBoolean;
+        humanReviewReady: z.ZodBoolean;
+        releaseReady: z.ZodBoolean;
+    }, z.core.$strict>;
+    summary: z.ZodObject<{
+        errors: z.ZodNumber;
+        warnings: z.ZodNumber;
+        info: z.ZodNumber;
+    }, z.core.$strict>;
+    passed: z.ZodBoolean;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type DesignDeliverable = z.infer<typeof designDeliverableSchema>;
+export type DesignIntelligenceFinding = z.infer<typeof designIntelligenceFindingSchema>;
+export type DesignDeliverableReport = z.infer<typeof designDeliverableReportSchema>;