specweave 0.21.1 → 0.21.3

package/dist/src/config/types.d.ts

@@ -0,0 +1,1357 @@
+/**
+ * SpecWeave Configuration Types
+ *
+ * Defines the structure for .specweave/config.json
+ * which stores all research insights and project settings.
+ */
+import { z } from 'zod';
+/**
+ * Research configuration schema
+ */
+export declare const ResearchConfigSchema: z.ZodObject<{
+    /** Vision & Market Research results */
+    vision: z.ZodOptional<z.ZodObject<{
+        keywords: z.ZodArray<z.ZodString, "many">;
+        market: z.ZodEnum<["productivity-saas", "healthcare", "fintech", "e-commerce", "education", "gaming", "social-network", "enterprise-b2b", "consumer-b2c", "marketplace", "iot", "blockchain", "ai-ml", "unknown"]>;
+        competitors: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+            strengths: z.ZodArray<z.ZodString, "many">;
+            weaknesses: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            url?: string;
+            strengths?: string[];
+            weaknesses?: string[];
+        }, {
+            name?: string;
+            url?: string;
+            strengths?: string[];
+            weaknesses?: string[];
+        }>, "many">;
+        opportunityScore: z.ZodNumber;
+        viralPotential: z.ZodBoolean;
+        followUpQuestions: z.ZodArray<z.ZodObject<{
+            question: z.ZodString;
+            type: z.ZodEnum<["open", "multiple-choice", "scale"]>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rationale: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type?: "open" | "multiple-choice" | "scale";
+            options?: string[];
+            question?: string;
+            rationale?: string;
+        }, {
+            type?: "open" | "multiple-choice" | "scale";
+            options?: string[];
+            question?: string;
+            rationale?: string;
+        }>, "many">;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        rawVision: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        keywords?: string[];
+        confidence?: number;
+        market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+        competitors?: {
+            name?: string;
+            url?: string;
+            strengths?: string[];
+            weaknesses?: string[];
+        }[];
+        opportunityScore?: number;
+        viralPotential?: boolean;
+        followUpQuestions?: {
+            type?: "open" | "multiple-choice" | "scale";
+            options?: string[];
+            question?: string;
+            rationale?: string;
+        }[];
+        rawVision?: string;
+    }, {
+        keywords?: string[];
+        confidence?: number;
+        market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+        competitors?: {
+            name?: string;
+            url?: string;
+            strengths?: string[];
+            weaknesses?: string[];
+        }[];
+        opportunityScore?: number;
+        viralPotential?: boolean;
+        followUpQuestions?: {
+            type?: "open" | "multiple-choice" | "scale";
+            options?: string[];
+            question?: string;
+            rationale?: string;
+        }[];
+        rawVision?: string;
+    }>>;
+    /** Compliance standards detected */
+    compliance: z.ZodOptional<z.ZodObject<{
+        standards: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            dataTypes: z.ZodArray<z.ZodEnum<["healthcare", "payment", "personal", "government", "student", "financial", "biometric", "location", "children", "sensitive"]>, "many">;
+            regions: z.ZodArray<z.ZodString, "many">;
+            teamImpact: z.ZodArray<z.ZodEnum<["auth-team", "data-team", "devsecops-team", "ciso", "dpo", "privacy-engineering", "payments-team", "compliance-team"]>, "many">;
+            costImpact: z.ZodString;
+            certificationRequired: z.ZodBoolean;
+            auditFrequency: z.ZodEnum<["annual", "quarterly", "continuous", "none"]>;
+            description: z.ZodOptional<z.ZodString>;
+            documentationUrl: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            description?: string;
+            id?: string;
+            dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+            regions?: string[];
+            teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+            costImpact?: string;
+            certificationRequired?: boolean;
+            auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+            documentationUrl?: string;
+        }, {
+            name?: string;
+            description?: string;
+            id?: string;
+            dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+            regions?: string[];
+            teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+            costImpact?: string;
+            certificationRequired?: boolean;
+            auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+            documentationUrl?: string;
+        }>, "many">;
+        teamRequirements: z.ZodArray<z.ZodString, "many">;
+        totalCostEstimate: z.ZodString;
+        recommendations: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        recommendations?: string[];
+        standards?: {
+            name?: string;
+            description?: string;
+            id?: string;
+            dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+            regions?: string[];
+            teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+            costImpact?: string;
+            certificationRequired?: boolean;
+            auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+            documentationUrl?: string;
+        }[];
+        teamRequirements?: string[];
+        totalCostEstimate?: string;
+    }, {
+        recommendations?: string[];
+        standards?: {
+            name?: string;
+            description?: string;
+            id?: string;
+            dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+            regions?: string[];
+            teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+            costImpact?: string;
+            certificationRequired?: boolean;
+            auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+            documentationUrl?: string;
+        }[];
+        teamRequirements?: string[];
+        totalCostEstimate?: string;
+    }>>;
+    /** Team recommendations */
+    teams: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        teamName: z.ZodString;
+        role: z.ZodString;
+        required: z.ZodBoolean;
+        reason: z.ZodString;
+        size: z.ZodString;
+        skills: z.ZodArray<z.ZodString, "many">;
+        serverlessAlternative: z.ZodOptional<z.ZodObject<{
+            service: z.ZodString;
+            costSavings: z.ZodNumber;
+            tradeoffs: z.ZodArray<z.ZodString, "many">;
+            pricingModel: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            service?: string;
+            costSavings?: number;
+            tradeoffs?: string[];
+            pricingModel?: string;
+        }, {
+            service?: string;
+            costSavings?: number;
+            tradeoffs?: string[];
+            pricingModel?: string;
+        }>>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        skills?: string[];
+        reason?: string;
+        required?: boolean;
+        priority?: number;
+        teamName?: string;
+        role?: string;
+        size?: string;
+        serverlessAlternative?: {
+            service?: string;
+            costSavings?: number;
+            tradeoffs?: string[];
+            pricingModel?: string;
+        };
+    }, {
+        skills?: string[];
+        reason?: string;
+        required?: boolean;
+        priority?: number;
+        teamName?: string;
+        role?: string;
+        size?: string;
+        serverlessAlternative?: {
+            service?: string;
+            costSavings?: number;
+            tradeoffs?: string[];
+            pricingModel?: string;
+        };
+    }>, "many">>;
+    /** Architecture decision */
+    architecture: z.ZodOptional<z.ZodObject<{
+        architecture: z.ZodEnum<["serverless", "traditional-monolith", "microservices", "modular-monolith", "jamstack", "hybrid"]>;
+        infrastructure: z.ZodArray<z.ZodString, "many">;
+        rationale: z.ZodString;
+        costEstimate: z.ZodObject<{
+            at1K: z.ZodString;
+            at10K: z.ZodString;
+            at100K: z.ZodString;
+            at1M: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            at1K?: string;
+            at10K?: string;
+            at100K?: string;
+            at1M?: string;
+        }, {
+            at1K?: string;
+            at10K?: string;
+            at100K?: string;
+            at1M?: string;
+        }>;
+        cloudCredits: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            amount: z.ZodString;
+            duration: z.ZodString;
+            requirements: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            url?: string;
+            requirements?: string;
+            provider?: string;
+            amount?: string;
+            duration?: string;
+        }, {
+            url?: string;
+            requirements?: string;
+            provider?: string;
+            amount?: string;
+            duration?: string;
+        }>, "many">;
+        projects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            stack: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            stack?: string[];
+            description?: string;
+        }, {
+            name?: string;
+            stack?: string[];
+            description?: string;
+        }>, "many">;
+        methodology: z.ZodEnum<["agile", "waterfall"]>;
+        alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            architecture: z.ZodEnum<["serverless", "traditional-monolith", "microservices", "modular-monolith", "jamstack", "hybrid"]>;
+            pros: z.ZodArray<z.ZodString, "many">;
+            cons: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            pros?: string[];
+            cons?: string[];
+        }, {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            pros?: string[];
+            cons?: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+        projects?: {
+            name?: string;
+            stack?: string[];
+            description?: string;
+        }[];
+        infrastructure?: string[];
+        rationale?: string;
+        costEstimate?: {
+            at1K?: string;
+            at10K?: string;
+            at100K?: string;
+            at1M?: string;
+        };
+        cloudCredits?: {
+            url?: string;
+            requirements?: string;
+            provider?: string;
+            amount?: string;
+            duration?: string;
+        }[];
+        methodology?: "agile" | "waterfall";
+        alternatives?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            pros?: string[];
+            cons?: string[];
+        }[];
+    }, {
+        architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+        projects?: {
+            name?: string;
+            stack?: string[];
+            description?: string;
+        }[];
+        infrastructure?: string[];
+        rationale?: string;
+        costEstimate?: {
+            at1K?: string;
+            at10K?: string;
+            at100K?: string;
+            at1M?: string;
+        };
+        cloudCredits?: {
+            url?: string;
+            requirements?: string;
+            provider?: string;
+            amount?: string;
+            duration?: string;
+        }[];
+        methodology?: "agile" | "waterfall";
+        alternatives?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            pros?: string[];
+            cons?: string[];
+        }[];
+    }>>;
+    /** Methodology (Agile or Waterfall) */
+    methodology: z.ZodOptional<z.ZodEnum<["agile", "waterfall"]>>;
+    /** Repository selection */
+    repositories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        owner: z.ZodString;
+        language: z.ZodOptional<z.ZodString>;
+        stars: z.ZodOptional<z.ZodNumber>;
+        lastUpdated: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        language?: string;
+        owner?: string;
+        url?: string;
+        stars?: number;
+        lastUpdated?: string;
+    }, {
+        name?: string;
+        language?: string;
+        owner?: string;
+        url?: string;
+        stars?: number;
+        lastUpdated?: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    architecture?: {
+        architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+        projects?: {
+            name?: string;
+            stack?: string[];
+            description?: string;
+        }[];
+        infrastructure?: string[];
+        rationale?: string;
+        costEstimate?: {
+            at1K?: string;
+            at10K?: string;
+            at100K?: string;
+            at1M?: string;
+        };
+        cloudCredits?: {
+            url?: string;
+            requirements?: string;
+            provider?: string;
+            amount?: string;
+            duration?: string;
+        }[];
+        methodology?: "agile" | "waterfall";
+        alternatives?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            pros?: string[];
+            cons?: string[];
+        }[];
+    };
+    repositories?: {
+        name?: string;
+        language?: string;
+        owner?: string;
+        url?: string;
+        stars?: number;
+        lastUpdated?: string;
+    }[];
+    teams?: {
+        skills?: string[];
+        reason?: string;
+        required?: boolean;
+        priority?: number;
+        teamName?: string;
+        role?: string;
+        size?: string;
+        serverlessAlternative?: {
+            service?: string;
+            costSavings?: number;
+            tradeoffs?: string[];
+            pricingModel?: string;
+        };
+    }[];
+    methodology?: "agile" | "waterfall";
+    vision?: {
+        keywords?: string[];
+        confidence?: number;
+        market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+        competitors?: {
+            name?: string;
+            url?: string;
+            strengths?: string[];
+            weaknesses?: string[];
+        }[];
+        opportunityScore?: number;
+        viralPotential?: boolean;
+        followUpQuestions?: {
+            type?: "open" | "multiple-choice" | "scale";
+            options?: string[];
+            question?: string;
+            rationale?: string;
+        }[];
+        rawVision?: string;
+    };
+    compliance?: {
+        recommendations?: string[];
+        standards?: {
+            name?: string;
+            description?: string;
+            id?: string;
+            dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+            regions?: string[];
+            teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+            costImpact?: string;
+            certificationRequired?: boolean;
+            auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+            documentationUrl?: string;
+        }[];
+        teamRequirements?: string[];
+        totalCostEstimate?: string;
+    };
+}, {
+    architecture?: {
+        architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+        projects?: {
+            name?: string;
+            stack?: string[];
+            description?: string;
+        }[];
+        infrastructure?: string[];
+        rationale?: string;
+        costEstimate?: {
+            at1K?: string;
+            at10K?: string;
+            at100K?: string;
+            at1M?: string;
+        };
+        cloudCredits?: {
+            url?: string;
+            requirements?: string;
+            provider?: string;
+            amount?: string;
+            duration?: string;
+        }[];
+        methodology?: "agile" | "waterfall";
+        alternatives?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            pros?: string[];
+            cons?: string[];
+        }[];
+    };
+    repositories?: {
+        name?: string;
+        language?: string;
+        owner?: string;
+        url?: string;
+        stars?: number;
+        lastUpdated?: string;
+    }[];
+    teams?: {
+        skills?: string[];
+        reason?: string;
+        required?: boolean;
+        priority?: number;
+        teamName?: string;
+        role?: string;
+        size?: string;
+        serverlessAlternative?: {
+            service?: string;
+            costSavings?: number;
+            tradeoffs?: string[];
+            pricingModel?: string;
+        };
+    }[];
+    methodology?: "agile" | "waterfall";
+    vision?: {
+        keywords?: string[];
+        confidence?: number;
+        market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+        competitors?: {
+            name?: string;
+            url?: string;
+            strengths?: string[];
+            weaknesses?: string[];
+        }[];
+        opportunityScore?: number;
+        viralPotential?: boolean;
+        followUpQuestions?: {
+            type?: "open" | "multiple-choice" | "scale";
+            options?: string[];
+            question?: string;
+            rationale?: string;
+        }[];
+        rawVision?: string;
+    };
+    compliance?: {
+        recommendations?: string[];
+        standards?: {
+            name?: string;
+            description?: string;
+            id?: string;
+            dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+            regions?: string[];
+            teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+            costImpact?: string;
+            certificationRequired?: boolean;
+            auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+            documentationUrl?: string;
+        }[];
+        teamRequirements?: string[];
+        totalCostEstimate?: string;
+    };
+}>;
+/**
+ * Living Docs configuration schema
+ */
+export declare const LivingDocsConfigSchema: z.ZodObject<{
+    /** Enable copy-based sync */
+    copyBasedSync: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean;
+    }, {
+        enabled?: boolean;
+    }>>;
+    /** Enable three-layer sync (GitHub <-> Living Docs <-> Increment) */
+    threeLayerSync: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    copyBasedSync?: {
+        enabled?: boolean;
+    };
+    threeLayerSync?: boolean;
+}, {
+    copyBasedSync?: {
+        enabled?: boolean;
+    };
+    threeLayerSync?: boolean;
+}>;
+/**
+ * Main SpecWeave configuration schema
+ */
+export declare const SpecWeaveConfigSchema: z.ZodObject<{
+    /** Config schema version */
+    version: z.ZodDefault<z.ZodString>;
+    /** Project name */
+    projectName: z.ZodString;
+    /** Research insights from strategic init */
+    research: z.ZodOptional<z.ZodObject<{
+        /** Vision & Market Research results */
+        vision: z.ZodOptional<z.ZodObject<{
+            keywords: z.ZodArray<z.ZodString, "many">;
+            market: z.ZodEnum<["productivity-saas", "healthcare", "fintech", "e-commerce", "education", "gaming", "social-network", "enterprise-b2b", "consumer-b2c", "marketplace", "iot", "blockchain", "ai-ml", "unknown"]>;
+            competitors: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+                strengths: z.ZodArray<z.ZodString, "many">;
+                weaknesses: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }, {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }>, "many">;
+            opportunityScore: z.ZodNumber;
+            viralPotential: z.ZodBoolean;
+            followUpQuestions: z.ZodArray<z.ZodObject<{
+                question: z.ZodString;
+                type: z.ZodEnum<["open", "multiple-choice", "scale"]>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                rationale: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }, {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }>, "many">;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            rawVision: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            keywords?: string[];
+            confidence?: number;
+            market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+            competitors?: {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }[];
+            opportunityScore?: number;
+            viralPotential?: boolean;
+            followUpQuestions?: {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }[];
+            rawVision?: string;
+        }, {
+            keywords?: string[];
+            confidence?: number;
+            market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+            competitors?: {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }[];
+            opportunityScore?: number;
+            viralPotential?: boolean;
+            followUpQuestions?: {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }[];
+            rawVision?: string;
+        }>>;
+        /** Compliance standards detected */
+        compliance: z.ZodOptional<z.ZodObject<{
+            standards: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                dataTypes: z.ZodArray<z.ZodEnum<["healthcare", "payment", "personal", "government", "student", "financial", "biometric", "location", "children", "sensitive"]>, "many">;
+                regions: z.ZodArray<z.ZodString, "many">;
+                teamImpact: z.ZodArray<z.ZodEnum<["auth-team", "data-team", "devsecops-team", "ciso", "dpo", "privacy-engineering", "payments-team", "compliance-team"]>, "many">;
+                costImpact: z.ZodString;
+                certificationRequired: z.ZodBoolean;
+                auditFrequency: z.ZodEnum<["annual", "quarterly", "continuous", "none"]>;
+                description: z.ZodOptional<z.ZodString>;
+                documentationUrl: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }, {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }>, "many">;
+            teamRequirements: z.ZodArray<z.ZodString, "many">;
+            totalCostEstimate: z.ZodString;
+            recommendations: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            recommendations?: string[];
+            standards?: {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }[];
+            teamRequirements?: string[];
+            totalCostEstimate?: string;
+        }, {
+            recommendations?: string[];
+            standards?: {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }[];
+            teamRequirements?: string[];
+            totalCostEstimate?: string;
+        }>>;
+        /** Team recommendations */
+        teams: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            teamName: z.ZodString;
+            role: z.ZodString;
+            required: z.ZodBoolean;
+            reason: z.ZodString;
+            size: z.ZodString;
+            skills: z.ZodArray<z.ZodString, "many">;
+            serverlessAlternative: z.ZodOptional<z.ZodObject<{
+                service: z.ZodString;
+                costSavings: z.ZodNumber;
+                tradeoffs: z.ZodArray<z.ZodString, "many">;
+                pricingModel: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            }, {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            }>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            skills?: string[];
+            reason?: string;
+            required?: boolean;
+            priority?: number;
+            teamName?: string;
+            role?: string;
+            size?: string;
+            serverlessAlternative?: {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            };
+        }, {
+            skills?: string[];
+            reason?: string;
+            required?: boolean;
+            priority?: number;
+            teamName?: string;
+            role?: string;
+            size?: string;
+            serverlessAlternative?: {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            };
+        }>, "many">>;
+        /** Architecture decision */
+        architecture: z.ZodOptional<z.ZodObject<{
+            architecture: z.ZodEnum<["serverless", "traditional-monolith", "microservices", "modular-monolith", "jamstack", "hybrid"]>;
+            infrastructure: z.ZodArray<z.ZodString, "many">;
+            rationale: z.ZodString;
+            costEstimate: z.ZodObject<{
+                at1K: z.ZodString;
+                at10K: z.ZodString;
+                at100K: z.ZodString;
+                at1M: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            }, {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            }>;
+            cloudCredits: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                amount: z.ZodString;
+                duration: z.ZodString;
+                requirements: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }, {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }>, "many">;
+            projects: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                stack: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }, {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }>, "many">;
+            methodology: z.ZodEnum<["agile", "waterfall"]>;
+            alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                architecture: z.ZodEnum<["serverless", "traditional-monolith", "microservices", "modular-monolith", "jamstack", "hybrid"]>;
+                pros: z.ZodArray<z.ZodString, "many">;
+                cons: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }, {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            projects?: {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }[];
+            infrastructure?: string[];
+            rationale?: string;
+            costEstimate?: {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            };
+            cloudCredits?: {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }[];
+            methodology?: "agile" | "waterfall";
+            alternatives?: {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }[];
+        }, {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            projects?: {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }[];
+            infrastructure?: string[];
+            rationale?: string;
+            costEstimate?: {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            };
+            cloudCredits?: {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }[];
+            methodology?: "agile" | "waterfall";
+            alternatives?: {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }[];
+        }>>;
+        /** Methodology (Agile or Waterfall) */
+        methodology: z.ZodOptional<z.ZodEnum<["agile", "waterfall"]>>;
+        /** Repository selection */
+        repositories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+            owner: z.ZodString;
+            language: z.ZodOptional<z.ZodString>;
+            stars: z.ZodOptional<z.ZodNumber>;
+            lastUpdated: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            language?: string;
+            owner?: string;
+            url?: string;
+            stars?: number;
+            lastUpdated?: string;
+        }, {
+            name?: string;
+            language?: string;
+            owner?: string;
+            url?: string;
+            stars?: number;
+            lastUpdated?: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        architecture?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            projects?: {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }[];
+            infrastructure?: string[];
+            rationale?: string;
+            costEstimate?: {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            };
+            cloudCredits?: {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }[];
+            methodology?: "agile" | "waterfall";
+            alternatives?: {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }[];
+        };
+        repositories?: {
+            name?: string;
+            language?: string;
+            owner?: string;
+            url?: string;
+            stars?: number;
+            lastUpdated?: string;
+        }[];
+        teams?: {
+            skills?: string[];
+            reason?: string;
+            required?: boolean;
+            priority?: number;
+            teamName?: string;
+            role?: string;
+            size?: string;
+            serverlessAlternative?: {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            };
+        }[];
+        methodology?: "agile" | "waterfall";
+        vision?: {
+            keywords?: string[];
+            confidence?: number;
+            market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+            competitors?: {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }[];
+            opportunityScore?: number;
+            viralPotential?: boolean;
+            followUpQuestions?: {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }[];
+            rawVision?: string;
+        };
+        compliance?: {
+            recommendations?: string[];
+            standards?: {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }[];
+            teamRequirements?: string[];
+            totalCostEstimate?: string;
+        };
+    }, {
+        architecture?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            projects?: {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }[];
+            infrastructure?: string[];
+            rationale?: string;
+            costEstimate?: {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            };
+            cloudCredits?: {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }[];
+            methodology?: "agile" | "waterfall";
+            alternatives?: {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }[];
+        };
+        repositories?: {
+            name?: string;
+            language?: string;
+            owner?: string;
+            url?: string;
+            stars?: number;
+            lastUpdated?: string;
+        }[];
+        teams?: {
+            skills?: string[];
+            reason?: string;
+            required?: boolean;
+            priority?: number;
+            teamName?: string;
+            role?: string;
+            size?: string;
+            serverlessAlternative?: {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            };
+        }[];
+        methodology?: "agile" | "waterfall";
+        vision?: {
+            keywords?: string[];
+            confidence?: number;
+            market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+            competitors?: {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }[];
+            opportunityScore?: number;
+            viralPotential?: boolean;
+            followUpQuestions?: {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }[];
+            rawVision?: string;
+        };
+        compliance?: {
+            recommendations?: string[];
+            standards?: {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }[];
+            teamRequirements?: string[];
+            totalCostEstimate?: string;
+        };
+    }>>;
+    /** Living docs settings */
+    livingDocs: z.ZodDefault<z.ZodObject<{
+        /** Enable copy-based sync */
+        copyBasedSync: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled?: boolean;
+        }, {
+            enabled?: boolean;
+        }>>;
+        /** Enable three-layer sync (GitHub <-> Living Docs <-> Increment) */
+        threeLayerSync: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        copyBasedSync?: {
+            enabled?: boolean;
+        };
+        threeLayerSync?: boolean;
+    }, {
+        copyBasedSync?: {
+            enabled?: boolean;
+        };
+        threeLayerSync?: boolean;
+    }>>;
+    /** Last updated timestamp */
+    lastUpdated: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    projectName?: string;
+    lastUpdated?: string;
+    research?: {
+        architecture?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            projects?: {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }[];
+            infrastructure?: string[];
+            rationale?: string;
+            costEstimate?: {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            };
+            cloudCredits?: {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }[];
+            methodology?: "agile" | "waterfall";
+            alternatives?: {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }[];
+        };
+        repositories?: {
+            name?: string;
+            language?: string;
+            owner?: string;
+            url?: string;
+            stars?: number;
+            lastUpdated?: string;
+        }[];
+        teams?: {
+            skills?: string[];
+            reason?: string;
+            required?: boolean;
+            priority?: number;
+            teamName?: string;
+            role?: string;
+            size?: string;
+            serverlessAlternative?: {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            };
+        }[];
+        methodology?: "agile" | "waterfall";
+        vision?: {
+            keywords?: string[];
+            confidence?: number;
+            market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+            competitors?: {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }[];
+            opportunityScore?: number;
+            viralPotential?: boolean;
+            followUpQuestions?: {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }[];
+            rawVision?: string;
+        };
+        compliance?: {
+            recommendations?: string[];
+            standards?: {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }[];
+            teamRequirements?: string[];
+            totalCostEstimate?: string;
+        };
+    };
+    livingDocs?: {
+        copyBasedSync?: {
+            enabled?: boolean;
+        };
+        threeLayerSync?: boolean;
+    };
+}, {
+    version?: string;
+    projectName?: string;
+    lastUpdated?: string;
+    research?: {
+        architecture?: {
+            architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+            projects?: {
+                name?: string;
+                stack?: string[];
+                description?: string;
+            }[];
+            infrastructure?: string[];
+            rationale?: string;
+            costEstimate?: {
+                at1K?: string;
+                at10K?: string;
+                at100K?: string;
+                at1M?: string;
+            };
+            cloudCredits?: {
+                url?: string;
+                requirements?: string;
+                provider?: string;
+                amount?: string;
+                duration?: string;
+            }[];
+            methodology?: "agile" | "waterfall";
+            alternatives?: {
+                architecture?: "serverless" | "traditional-monolith" | "microservices" | "modular-monolith" | "jamstack" | "hybrid";
+                pros?: string[];
+                cons?: string[];
+            }[];
+        };
+        repositories?: {
+            name?: string;
+            language?: string;
+            owner?: string;
+            url?: string;
+            stars?: number;
+            lastUpdated?: string;
+        }[];
+        teams?: {
+            skills?: string[];
+            reason?: string;
+            required?: boolean;
+            priority?: number;
+            teamName?: string;
+            role?: string;
+            size?: string;
+            serverlessAlternative?: {
+                service?: string;
+                costSavings?: number;
+                tradeoffs?: string[];
+                pricingModel?: string;
+            };
+        }[];
+        methodology?: "agile" | "waterfall";
+        vision?: {
+            keywords?: string[];
+            confidence?: number;
+            market?: "unknown" | "marketplace" | "productivity-saas" | "healthcare" | "fintech" | "e-commerce" | "education" | "gaming" | "social-network" | "enterprise-b2b" | "consumer-b2c" | "iot" | "blockchain" | "ai-ml";
+            competitors?: {
+                name?: string;
+                url?: string;
+                strengths?: string[];
+                weaknesses?: string[];
+            }[];
+            opportunityScore?: number;
+            viralPotential?: boolean;
+            followUpQuestions?: {
+                type?: "open" | "multiple-choice" | "scale";
+                options?: string[];
+                question?: string;
+                rationale?: string;
+            }[];
+            rawVision?: string;
+        };
+        compliance?: {
+            recommendations?: string[];
+            standards?: {
+                name?: string;
+                description?: string;
+                id?: string;
+                dataTypes?: ("location" | "payment" | "healthcare" | "personal" | "government" | "student" | "financial" | "biometric" | "children" | "sensitive")[];
+                regions?: string[];
+                teamImpact?: ("auth-team" | "data-team" | "devsecops-team" | "ciso" | "dpo" | "privacy-engineering" | "payments-team" | "compliance-team")[];
+                costImpact?: string;
+                certificationRequired?: boolean;
+                auditFrequency?: "none" | "annual" | "quarterly" | "continuous";
+                documentationUrl?: string;
+            }[];
+            teamRequirements?: string[];
+            totalCostEstimate?: string;
+        };
+    };
+    livingDocs?: {
+        copyBasedSync?: {
+            enabled?: boolean;
+        };
+        threeLayerSync?: boolean;
+    };
+}>;
+/**
+ * Type definitions
+ */
+export type ResearchConfig = z.infer<typeof ResearchConfigSchema>;
+export type LivingDocsConfig = z.infer<typeof LivingDocsConfigSchema>;
+export type SpecWeaveConfig = z.infer<typeof SpecWeaveConfigSchema>;
+//# sourceMappingURL=types.d.ts.map