@pactosigna/schemas 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,6 +1,1806 @@
-export { AcceptabilityStatusSchema, AnomalyCategory, AnomalyCategorySchema, AnomalyDisposition, AnomalyDispositionSchema, AnomalyFrontmatter, AnomalyFrontmatterSchema, AnomalySeverity, AnomalySeveritySchema, AuditFinding, AuditFindingClassification, AuditFindingClassificationSchema, AuditFindingSchema, AuditReportFrontmatter, AuditReportFrontmatterSchema, AuditScheduleFrontmatter, AuditScheduleFrontmatterSchema, AuditStatus, AuditStatusSchema, CHANGE_DOCUMENT_TYPES, ChangeDocumentType, ClinicalEvaluationPlanFrontmatter, ClinicalEvaluationPlanFrontmatterSchema, ClinicalEvaluationReportFrontmatter, ClinicalEvaluationReportFrontmatterSchema, CybersecurityPlanFrontmatter, CybersecurityPlanFrontmatterSchema, DEVICE_DOCUMENT_TYPES, DOCUMENT_TYPES, DesignReviewFrontmatter, DesignReviewFrontmatterSchema, DeviceDocumentType, DocumentStatusSchema, DocumentTypeSchema, HarmFrontmatter, HarmFrontmatterSchema, HazardCategoryFrontmatter, HazardCategoryFrontmatterSchema, HazardFrontmatter, HazardFrontmatterSchema, HazardousSituationFrontmatter, HazardousSituationFrontmatterSchema, IntendedUseFrontmatter, IntendedUseFrontmatterSchema, LINK_TYPES, LabelingFrontmatter, LabelingFrontmatterSchema, LinkTypeSchema, ManagementReviewAttendee, ManagementReviewAttendeeSchema, ManagementReviewFrontmatter, ManagementReviewFrontmatterSchema, Mitigation, MitigationSchema, MitigationTargetSchema, PlannedAuditEntry, PlannedAuditEntrySchema, PostMarketFeedbackCategorySchema, PostMarketFeedbackFrontmatter, PostMarketFeedbackFrontmatterSchema, PostMarketFeedbackSeveritySchema, PostMarketSurveillancePlanFrontmatter, PostMarketSurveillancePlanFrontmatterSchema, ProductDevelopmentPlanFrontmatter, ProductDevelopmentPlanFrontmatterSchema, QMS_DOCUMENT_TYPES, QmsDocumentType, REQUIRED_SECTIONS, RegulatoryFrameworkSchema, ReleaseNotesAudience, ReleaseNotesAudienceSchema, ReleaseNotesFrontmatter, ReleaseNotesFrontmatterSchema, ReleasePlanFrontmatter, ReleasePlanFrontmatterSchema, ReleaseReviewConfig, ReleaseReviewConfigSchema, RepoConfig, RepoConfigSchema, RequirementFormat, RequirementFormatSchema, RequirementFrontmatter, RequirementFrontmatterSchema, RequirementFulfillmentType, RequirementFulfillmentTypeSchema, RequirementType, RequirementTypeSchema, RetentionPolicy, RetentionPolicySchema, RiskDocumentStatus, RiskDocumentStatusSchema, RiskEntryFrontmatter, RiskEntryFrontmatterSchema, RiskGapCodeSchema, RiskGapSeveritySchema, RiskManagementPlanFrontmatter, RiskManagementPlanFrontmatterSchema, RiskMatrixConfig, RiskMatrixConfigSchema, SafetyClassSchema, SbomFrontmatter, SbomFrontmatterSchema, SoftwareDevelopmentPlanFrontmatter, SoftwareDevelopmentPlanFrontmatterSchema, SoftwareMaintenancePlanFrontmatter, SoftwareMaintenancePlanFrontmatterSchema, SoftwareTestPlanFrontmatter, SoftwareTestPlanFrontmatterSchema, SoupRegisterFrontmatter, SoupRegisterFrontmatterSchema, SummativeEvaluationFrontmatter, SummativeEvaluationFrontmatterSchema, TaskAnalysisFrontmatter, TaskAnalysisFrontmatterSchema, TestPhase, TestPhaseSchema, TestProtocolFrontmatter, TestProtocolFrontmatterSchema, TestReportFrontmatter, TestReportFrontmatterSchema, UsabilityEvaluationFrontmatter, UsabilityEvaluationFrontmatterSchema, UsabilityPlanFrontmatter, UsabilityPlanFrontmatterSchema, UseSpecificationFrontmatter, UseSpecificationFrontmatterSchema, UserNeedFrontmatter, UserNeedFrontmatterSchema, UserNeedPriority, UserNeedPrioritySchema, getEffectiveRetentionYears, isChangeDocumentType, isDeviceDocumentType, isQmsDocumentType, isWithinRetentionPeriod } from '@pactosigna/shared';
 import { z } from 'zod';
-export { FOLDER_RULES, FolderRule, JSON_SBOM_FOLDERS, NON_REGULATED_FOLDERS, findFolderRule, inferDocumentType } from './document-type-patterns.js';
+import { D as DocumentType, L as LinkType } from './document-type-patterns-JuAGFi_j.js';
+export { F as FOLDER_RULES, a as FolderRule, J as JSON_SBOM_FOLDERS, N as NON_REGULATED_FOLDERS, f as findFolderRule, i as inferDocumentType } from './document-type-patterns-JuAGFi_j.js';
+
+/**
+ * Common Zod enum schemas shared across multiple schema files.
+ *
+ * Extracted from index.ts to avoid circular dependencies when other
+ * schema files (e.g. frameworks.ts) need to reference these enums
+ * while also being re-exported from index.ts.
+ */
+
+declare const RegulatoryFrameworkSchema: z.ZodEnum<["ISO_13485", "IEC_62304", "FDA_21_CFR_820", "QMSR", "EU_MDR", "ISO_14971", "AI_ACT"]>;
+declare const SafetyClassSchema: z.ZodEnum<["A", "B", "C"]>;
+declare const DocumentTypeSchema: z.ZodEnum<["user_need", "requirement", "architecture", "detailed_design", "test_protocol", "test_report", "sop", "work_instruction", "policy", "usability_risk", "software_risk", "security_risk", "haz_soe_software", "haz_soe_security", "hazardous_situation", "harm", "hazard_category", "usability_plan", "use_specification", "task_analysis", "usability_evaluation", "summative_evaluation", "risk_management_plan", "software_development_plan", "software_maintenance_plan", "soup_register", "anomaly", "cybersecurity_plan", "sbom", "clinical_evaluation_plan", "clinical_evaluation_report", "post_market_surveillance_plan", "post_market_feedback", "labeling", "product_development_plan", "intended_use", "release_plan", "design_review", "release_notes", "supplier", "audit_schedule", "audit_report", "management_review", "software_test_plan"]>;
+declare const DocumentStatusSchema: z.ZodEnum<["draft", "in_review", "approved", "obsolete", "example"]>;
+declare const LinkTypeSchema: z.ZodEnum<["derives_from", "implements", "verified_by", "mitigates", "parent_of", "related_to", "leads_to", "results_in", "analyzes"]>;
+declare const AcceptabilityStatusSchema: z.ZodEnum<["acceptable", "review_required", "unacceptable"]>;
+
+declare const RiskDocumentStatusSchema: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+declare const MitigationTargetSchema: z.ZodEnum<["sequence_probability", "harm_probability", "severity"]>;
+declare const RiskGapCodeSchema: z.ZodEnum<["hazard_no_situation", "situation_no_harm", "hazard_not_analyzed", "missing_mitigation", "broken_mitigation_link", "control_not_approved", "missing_risk_benefit", "risk_missing_safety_chain", "risk_broken_safety_chain", "wrong_probability_dimension", "missing_frontmatter", "requirement_no_architecture", "architecture_no_segregation", "architecture_no_parent", "haz_missing_category", "haz_invalid_category", "category_not_approved"]>;
+declare const RiskGapSeveritySchema: z.ZodEnum<["error", "warning"]>;
+declare const MitigationSchema: z.ZodObject<{
+    control: z.ZodString;
+    reduces: z.ZodEnum<["sequence_probability", "harm_probability", "severity"]>;
+    for_harm: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    control: string;
+    reduces: "sequence_probability" | "harm_probability" | "severity";
+    for_harm?: string | undefined;
+}, {
+    control: string;
+    reduces: "sequence_probability" | "harm_probability" | "severity";
+    for_harm?: string | undefined;
+}>;
+declare const RiskEntryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
+    type: z.ZodEnum<["software_risk", "usability_risk", "security_risk"]>;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    analyzes: z.ZodString;
+    hazardous_situation: z.ZodString;
+    harm_assessments: z.ZodArray<z.ZodObject<{
+        harm: z.ZodString;
+        inherent_probability: z.ZodOptional<z.ZodNumber>;
+        inherent_exploitability: z.ZodOptional<z.ZodNumber>;
+        residual_probability: z.ZodOptional<z.ZodNumber>;
+        residual_exploitability: z.ZodOptional<z.ZodNumber>;
+        residual_severity_override: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        harm: string;
+        inherent_probability?: number | undefined;
+        inherent_exploitability?: number | undefined;
+        residual_probability?: number | undefined;
+        residual_exploitability?: number | undefined;
+        residual_severity_override?: number | undefined;
+    }, {
+        harm: string;
+        inherent_probability?: number | undefined;
+        inherent_exploitability?: number | undefined;
+        residual_probability?: number | undefined;
+        residual_exploitability?: number | undefined;
+        residual_severity_override?: number | undefined;
+    }>, "many">;
+    mitigations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        control: z.ZodString;
+        reduces: z.ZodEnum<["sequence_probability", "harm_probability", "severity"]>;
+        for_harm: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        control: string;
+        reduces: "sequence_probability" | "harm_probability" | "severity";
+        for_harm?: string | undefined;
+    }, {
+        control: string;
+        reduces: "sequence_probability" | "harm_probability" | "severity";
+        for_harm?: string | undefined;
+    }>, "many">>;
+    cvss_score: z.ZodOptional<z.ZodNumber>;
+    cvss_vector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "software_risk" | "usability_risk" | "security_risk";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    analyzes: string;
+    hazardous_situation: string;
+    harm_assessments: {
+        harm: string;
+        inherent_probability?: number | undefined;
+        inherent_exploitability?: number | undefined;
+        residual_probability?: number | undefined;
+        residual_exploitability?: number | undefined;
+        residual_severity_override?: number | undefined;
+    }[];
+    mitigations?: {
+        control: string;
+        reduces: "sequence_probability" | "harm_probability" | "severity";
+        for_harm?: string | undefined;
+    }[] | undefined;
+    cvss_score?: number | undefined;
+    cvss_vector?: string | undefined;
+}, {
+    type: "software_risk" | "usability_risk" | "security_risk";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    analyzes: string;
+    hazardous_situation: string;
+    harm_assessments: {
+        harm: string;
+        inherent_probability?: number | undefined;
+        inherent_exploitability?: number | undefined;
+        residual_probability?: number | undefined;
+        residual_exploitability?: number | undefined;
+        residual_severity_override?: number | undefined;
+    }[];
+    mitigations?: {
+        control: string;
+        reduces: "sequence_probability" | "harm_probability" | "severity";
+        for_harm?: string | undefined;
+    }[] | undefined;
+    cvss_score?: number | undefined;
+    cvss_vector?: string | undefined;
+}>, {
+    type: "software_risk" | "usability_risk" | "security_risk";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    analyzes: string;
+    hazardous_situation: string;
+    harm_assessments: {
+        harm: string;
+        inherent_probability?: number | undefined;
+        inherent_exploitability?: number | undefined;
+        residual_probability?: number | undefined;
+        residual_exploitability?: number | undefined;
+        residual_severity_override?: number | undefined;
+    }[];
+    mitigations?: {
+        control: string;
+        reduces: "sequence_probability" | "harm_probability" | "severity";
+        for_harm?: string | undefined;
+    }[] | undefined;
+    cvss_score?: number | undefined;
+    cvss_vector?: string | undefined;
+}, {
+    type: "software_risk" | "usability_risk" | "security_risk";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    analyzes: string;
+    hazardous_situation: string;
+    harm_assessments: {
+        harm: string;
+        inherent_probability?: number | undefined;
+        inherent_exploitability?: number | undefined;
+        residual_probability?: number | undefined;
+        residual_exploitability?: number | undefined;
+        residual_severity_override?: number | undefined;
+    }[];
+    mitigations?: {
+        control: string;
+        reduces: "sequence_probability" | "harm_probability" | "severity";
+        for_harm?: string | undefined;
+    }[] | undefined;
+    cvss_score?: number | undefined;
+    cvss_vector?: string | undefined;
+}>;
+declare const HazardFrontmatterSchema: z.ZodObject<{
+    type: z.ZodEnum<["haz_soe_software", "haz_soe_security"]>;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    leads_to: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    failure_mode: z.ZodOptional<z.ZodString>;
+    cause: z.ZodOptional<z.ZodString>;
+    detection_method: z.ZodOptional<z.ZodString>;
+    threat_category: z.ZodOptional<z.ZodString>;
+    attack_vector: z.ZodOptional<z.ZodString>;
+    hazard_category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "haz_soe_software" | "haz_soe_security";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    leads_to?: string[] | undefined;
+    failure_mode?: string | undefined;
+    cause?: string | undefined;
+    detection_method?: string | undefined;
+    threat_category?: string | undefined;
+    attack_vector?: string | undefined;
+    hazard_category?: string | undefined;
+}, {
+    type: "haz_soe_software" | "haz_soe_security";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    leads_to?: string[] | undefined;
+    failure_mode?: string | undefined;
+    cause?: string | undefined;
+    detection_method?: string | undefined;
+    threat_category?: string | undefined;
+    attack_vector?: string | undefined;
+    hazard_category?: string | undefined;
+}>;
+declare const HazardCategoryFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hazard_category">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    source: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "hazard_category";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    source?: string | undefined;
+}, {
+    type: "hazard_category";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    source?: string | undefined;
+}>;
+declare const HazardousSituationFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hazardous_situation">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    results_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "hazardous_situation";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    results_in?: string[] | undefined;
+}, {
+    type: "hazardous_situation";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    results_in?: string[] | undefined;
+}>;
+declare const HarmFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"harm">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    severity: z.ZodNumber;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    severity: number;
+    type: "harm";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    category?: string | undefined;
+}, {
+    severity: number;
+    type: "harm";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    category?: string | undefined;
+}>;
+declare const RiskMatrixConfigSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    labels: z.ZodObject<{
+        severity: z.ZodArray<z.ZodString, "many">;
+        probability: z.ZodArray<z.ZodString, "many">;
+        exploitability: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        severity: string[];
+        probability: string[];
+        exploitability?: string[] | undefined;
+    }, {
+        severity: string[];
+        probability: string[];
+        exploitability?: string[] | undefined;
+    }>;
+    acceptability: z.ZodObject<{
+        unacceptable: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+        review_required: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    }, {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    }>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        unacceptable: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+        review_required: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    }, {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    labels: {
+        severity: string[];
+        probability: string[];
+        exploitability?: string[] | undefined;
+    };
+    acceptability: {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    };
+    overrides?: Record<string, {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    }> | undefined;
+}, {
+    version: number;
+    labels: {
+        severity: string[];
+        probability: string[];
+        exploitability?: string[] | undefined;
+    };
+    acceptability: {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    };
+    overrides?: Record<string, {
+        unacceptable: [number, number][];
+        review_required?: [number, number][] | undefined;
+    }> | undefined;
+}>;
+type RiskDocumentStatus = z.infer<typeof RiskDocumentStatusSchema>;
+type Mitigation = z.infer<typeof MitigationSchema>;
+type RiskEntryFrontmatter = z.infer<typeof RiskEntryFrontmatterSchema>;
+type HazardFrontmatter = z.infer<typeof HazardFrontmatterSchema>;
+type HazardousSituationFrontmatter = z.infer<typeof HazardousSituationFrontmatterSchema>;
+type HazardCategoryFrontmatter = z.infer<typeof HazardCategoryFrontmatterSchema>;
+type HarmFrontmatter = z.infer<typeof HarmFrontmatterSchema>;
+type RiskMatrixConfig = z.infer<typeof RiskMatrixConfigSchema>;
+
+/**
+ * Zod schemas for IEC 62366 Usability Engineering document types.
+ *
+ * These schemas validate frontmatter for usability engineering artifacts:
+ * - Usability Plan (UEP-*)
+ * - Use Specification (US-*)
+ * - Task Analysis (TA-*)
+ * - Usability Evaluation (UE-*)
+ * - Summative Evaluation (SE-*)
+ *
+ * Content-heavy fields have been moved to markdown sections.
+ * Only fields needed for computation/filtering remain in frontmatter.
+ */
+
+declare const UsabilityPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"usability_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "usability_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "usability_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const UseSpecificationFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"use_specification">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    user_group: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "use_specification";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    user_group: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "use_specification";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    user_group: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const TaskAnalysisFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"task_analysis">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    user_group: z.ZodString;
+    critical_task: z.ZodBoolean;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "task_analysis";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    user_group: string;
+    critical_task: boolean;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "task_analysis";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    user_group: string;
+    critical_task: boolean;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const UsabilityEvaluationFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"usability_evaluation">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    result: z.ZodOptional<z.ZodEnum<["pass", "fail", "pass_with_findings"]>>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "usability_evaluation";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    result?: "pass" | "fail" | "pass_with_findings" | undefined;
+}, {
+    type: "usability_evaluation";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    result?: "pass" | "fail" | "pass_with_findings" | undefined;
+}>;
+declare const SummativeEvaluationFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"summative_evaluation">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    result: z.ZodOptional<z.ZodEnum<["pass", "fail", "pass_with_findings"]>>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "summative_evaluation";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    result?: "pass" | "fail" | "pass_with_findings" | undefined;
+}, {
+    type: "summative_evaluation";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    result?: "pass" | "fail" | "pass_with_findings" | undefined;
+}>;
+type UsabilityPlanFrontmatter = z.infer<typeof UsabilityPlanFrontmatterSchema>;
+type UseSpecificationFrontmatter = z.infer<typeof UseSpecificationFrontmatterSchema>;
+type TaskAnalysisFrontmatter = z.infer<typeof TaskAnalysisFrontmatterSchema>;
+type UsabilityEvaluationFrontmatter = z.infer<typeof UsabilityEvaluationFrontmatterSchema>;
+type SummativeEvaluationFrontmatter = z.infer<typeof SummativeEvaluationFrontmatterSchema>;
+
+/**
+ * Zod schema for ISO 14971 Risk Management Plan document type.
+ *
+ * Validates frontmatter for risk management plan artifacts (RMP-*).
+ * Content fields (device_description, safety_class, team, etc.) are now
+ * markdown sections, not frontmatter. Safety class comes from pactosigna.yml.
+ */
+
+declare const RiskManagementPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"risk_management_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "risk_management_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "risk_management_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type RiskManagementPlanFrontmatter = z.infer<typeof RiskManagementPlanFrontmatterSchema>;
+
+/**
+ * Zod schemas for IEC 62304 Software Lifecycle document types.
+ */
+
+declare const SoftwareDevelopmentPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"software_development_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "software_development_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "software_development_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const SoftwareMaintenancePlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"software_maintenance_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "software_maintenance_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "software_maintenance_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const SoupRegisterFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"soup_register">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "soup_register";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "soup_register";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const SoftwareTestPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"software_test_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "software_test_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "software_test_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type SoftwareDevelopmentPlanFrontmatter = z.infer<typeof SoftwareDevelopmentPlanFrontmatterSchema>;
+type SoftwareMaintenancePlanFrontmatter = z.infer<typeof SoftwareMaintenancePlanFrontmatterSchema>;
+type SoupRegisterFrontmatter = z.infer<typeof SoupRegisterFrontmatterSchema>;
+type SoftwareTestPlanFrontmatter = z.infer<typeof SoftwareTestPlanFrontmatterSchema>;
+
+/**
+ * Zod schemas for IEC 62304 §9 Software Problem Resolution (Anomaly) document type.
+ *
+ * `status` = document approval lifecycle (draft → approved), shared with other doc types.
+ * `disposition` = problem resolution state (open → resolved/deferred/will_not_fix).
+ */
+
+declare const AnomalyCategorySchema: z.ZodEnum<["bug", "security_vulnerability", "regression", "performance"]>;
+declare const AnomalySeveritySchema: z.ZodEnum<["critical", "major", "minor"]>;
+declare const AnomalyDispositionSchema: z.ZodEnum<["open", "investigating", "resolved", "deferred", "will_not_fix"]>;
+declare const AnomalyFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"anomaly">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    category: z.ZodEnum<["bug", "security_vulnerability", "regression", "performance"]>;
+    severity: z.ZodEnum<["critical", "major", "minor"]>;
+    disposition: z.ZodEnum<["open", "investigating", "resolved", "deferred", "will_not_fix"]>;
+    affected_version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    severity: "critical" | "major" | "minor";
+    type: "anomaly";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    category: "performance" | "bug" | "security_vulnerability" | "regression";
+    disposition: "open" | "investigating" | "resolved" | "deferred" | "will_not_fix";
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    affected_version?: string | undefined;
+}, {
+    severity: "critical" | "major" | "minor";
+    type: "anomaly";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    category: "performance" | "bug" | "security_vulnerability" | "regression";
+    disposition: "open" | "investigating" | "resolved" | "deferred" | "will_not_fix";
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    affected_version?: string | undefined;
+}>;
+type AnomalyCategory = z.infer<typeof AnomalyCategorySchema>;
+type AnomalySeverity = z.infer<typeof AnomalySeveritySchema>;
+type AnomalyDisposition = z.infer<typeof AnomalyDispositionSchema>;
+type AnomalyFrontmatter = z.infer<typeof AnomalyFrontmatterSchema>;
+
+/**
+ * Zod schemas for IEC 81001-5-1 Cybersecurity document types.
+ */
+
+declare const CybersecurityPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cybersecurity_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "cybersecurity_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "cybersecurity_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const SbomFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"sbom">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "sbom";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "sbom";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type CybersecurityPlanFrontmatter = z.infer<typeof CybersecurityPlanFrontmatterSchema>;
+type SbomFrontmatter = z.infer<typeof SbomFrontmatterSchema>;
+
+/**
+ * Zod schemas for Clinical (MDR / FDA) document types.
+ */
+
+declare const ClinicalEvaluationPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"clinical_evaluation_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "clinical_evaluation_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "clinical_evaluation_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const ClinicalEvaluationReportFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"clinical_evaluation_report">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "clinical_evaluation_report";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "clinical_evaluation_report";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type ClinicalEvaluationPlanFrontmatter = z.infer<typeof ClinicalEvaluationPlanFrontmatterSchema>;
+type ClinicalEvaluationReportFrontmatter = z.infer<typeof ClinicalEvaluationReportFrontmatterSchema>;
+
+/**
+ * Zod schema for MDR Art. 83 Post-Market Surveillance document type.
+ */
+
+declare const PostMarketSurveillancePlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"post_market_surveillance_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "post_market_surveillance_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "post_market_surveillance_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type PostMarketSurveillancePlanFrontmatter = z.infer<typeof PostMarketSurveillancePlanFrontmatterSchema>;
+declare const PostMarketFeedbackCategorySchema: z.ZodEnum<["complaint", "field_observation", "clinical_followup", "trend_report"]>;
+declare const PostMarketFeedbackSeveritySchema: z.ZodEnum<["low", "medium", "high", "critical"]>;
+declare const PostMarketFeedbackFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"post_market_feedback">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    category: z.ZodEnum<["complaint", "field_observation", "clinical_followup", "trend_report"]>;
+    severity: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    device: z.ZodOptional<z.ZodString>;
+    reporting_period: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    severity: "low" | "medium" | "high" | "critical";
+    type: "post_market_feedback";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    category: "complaint" | "field_observation" | "clinical_followup" | "trend_report";
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    device?: string | undefined;
+    reporting_period?: string | undefined;
+}, {
+    severity: "low" | "medium" | "high" | "critical";
+    type: "post_market_feedback";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    category: "complaint" | "field_observation" | "clinical_followup" | "trend_report";
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    device?: string | undefined;
+    reporting_period?: string | undefined;
+}>;
+type PostMarketFeedbackFrontmatter = z.infer<typeof PostMarketFeedbackFrontmatterSchema>;
+
+/**
+ * Zod schema for MDR Annex I Labeling document type.
+ */
+
+declare const LabelingFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"labeling">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    label_type: z.ZodOptional<z.ZodEnum<["ifu", "product_label", "packaging_label"]>>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "labeling";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    label_type?: "ifu" | "product_label" | "packaging_label" | undefined;
+}, {
+    type: "labeling";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    label_type?: "ifu" | "product_label" | "packaging_label" | undefined;
+}>;
+type LabelingFrontmatter = z.infer<typeof LabelingFrontmatterSchema>;
+
+/**
+ * Zod schemas for Product-level document types (ISO 13485 §7.3).
+ */
+
+declare const ProductDevelopmentPlanFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"product_development_plan">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "product_development_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "product_development_plan";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const IntendedUseFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"intended_use">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "intended_use";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "intended_use";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type ProductDevelopmentPlanFrontmatter = z.infer<typeof ProductDevelopmentPlanFrontmatterSchema>;
+type IntendedUseFrontmatter = z.infer<typeof IntendedUseFrontmatterSchema>;
+
+/**
+ * Zod schemas for User Need document frontmatter (ISO 13485 §7.3.2).
+ *
+ * User needs are design inputs that capture WHAT a user or stakeholder needs
+ * from the system. They are the top of the traceability chain:
+ *   User Need → Product Requirement → Software Requirement → Implementation → Test
+ *
+ * Note: document type (`docType: 'user_need'`) is inferred from the repository
+ * folder path at sync time and is NOT a frontmatter field authors need to write.
+ */
+
+/**
+ * ISO 13485 §7.3.2 — user need priority classification.
+ * Maps to MoSCoW prioritization for design input triage.
+ */
+declare const UserNeedPrioritySchema: z.ZodEnum<["must_have", "should_have", "nice_to_have"]>;
+declare const UserNeedFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    /** Validated if present — ensures frontmatter doesn't misidentify the document type */
+    type: z.ZodOptional<z.ZodLiteral<"user_need">>;
+    /** The user role or stakeholder (e.g., "Quality Manager", "Developer") */
+    stakeholder: z.ZodOptional<z.ZodString>;
+    /** MoSCoW priority classification */
+    priority: z.ZodOptional<z.ZodEnum<["must_have", "should_have", "nice_to_have"]>>;
+    /** Where this need originated (e.g., "ISO 13485 §7.3", "user interview") */
+    source: z.ZodOptional<z.ZodString>;
+    /** IDs of product requirements derived from this need */
+    derives: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    type?: "user_need" | undefined;
+    source?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    stakeholder?: string | undefined;
+    priority?: "must_have" | "should_have" | "nice_to_have" | undefined;
+    derives?: string[] | undefined;
+}, {
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    type?: "user_need" | undefined;
+    source?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    stakeholder?: string | undefined;
+    priority?: "must_have" | "should_have" | "nice_to_have" | undefined;
+    derives?: string[] | undefined;
+}>;
+type UserNeedPriority = z.infer<typeof UserNeedPrioritySchema>;
+type UserNeedFrontmatter = z.infer<typeof UserNeedFrontmatterSchema>;
+
+/**
+ * Zod schemas for Requirement document frontmatter (IEC 62304 §5.2.2, ISO 13485 §7.3.3).
+ *
+ * Note: document type (`docType: 'requirement'`) and category (`product` vs `software`)
+ * are both inferred from the repository folder path at sync time and are NOT
+ * frontmatter fields authors need to write.
+ */
+
+/**
+ * IEC 62304 §5.2.2 — software requirement classification.
+ * Only meaningful for SRS (category='software') documents; optional for PRS.
+ */
+declare const RequirementTypeSchema: z.ZodEnum<["functional", "interface", "performance", "security", "usability", "safety", "regulatory"]>;
+/**
+ * Authoring format for requirement documents.
+ * - standard: traditional "The system shall..." style with ## Requirements + ## Verification Criteria
+ * - user_story: agile "As a [role] I want..." style with ## User Story + ## Acceptance Criteria (BDD/Gherkin)
+ */
+declare const RequirementFormatSchema: z.ZodEnum<["standard", "user_story"]>;
+/**
+ * ISO 13485 §7.3.3 — how a PRS design input is fulfilled.
+ * Only meaningful on PRS (category='product') documents; ignored on SRS.
+ * Default (when omitted) is 'software' — existing PRS without this field are unaffected.
+ *
+ * - software:       Fulfilled by SRS → code (default; existing behaviour)
+ * - labeling:       Fulfilled by an IFU or label design document
+ * - clinical:       Fulfilled by a clinical evaluation report
+ * - usability:      Fulfilled by a summative evaluation or use specification
+ * - regulatory_doc: Fulfilled by a compliance document (e.g. HIPAA risk analysis)
+ * - process:        Fulfilled by an SOP or work instruction
+ */
+declare const RequirementFulfillmentTypeSchema: z.ZodEnum<["software", "labeling", "clinical", "usability", "regulatory_doc", "process"]>;
+declare const RequirementFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    /** IEC 62304 §5.2.2 — requirement classification (required for SRS, optional for PRS) */
+    req_type: z.ZodOptional<z.ZodEnum<["functional", "interface", "performance", "security", "usability", "safety", "regulatory"]>>;
+    /** Authoring convention — controls which required sections are checked */
+    format: z.ZodOptional<z.ZodEnum<["standard", "user_story"]>>;
+    /** ISO 13485 §7.3.3 — how this PRS design input is fulfilled (PRS only, defaults to 'software') */
+    fulfillment_type: z.ZodOptional<z.ZodEnum<["software", "labeling", "clinical", "usability", "regulatory_doc", "process"]>>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Upstream traceability — IDs of documents this requirement traces from (e.g., UN for PRS, PRS for SRS) */
+    traces_from: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Downstream traceability — IDs of documents this requirement traces to (e.g., SRS for PRS) */
+    traces_to: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    req_type?: "safety" | "performance" | "usability" | "regulatory" | "functional" | "interface" | "security" | undefined;
+    format?: "standard" | "user_story" | undefined;
+    fulfillment_type?: "labeling" | "usability" | "software" | "clinical" | "regulatory_doc" | "process" | undefined;
+    traces_from?: string[] | undefined;
+    traces_to?: string[] | undefined;
+}, {
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    req_type?: "safety" | "performance" | "usability" | "regulatory" | "functional" | "interface" | "security" | undefined;
+    format?: "standard" | "user_story" | undefined;
+    fulfillment_type?: "labeling" | "usability" | "software" | "clinical" | "regulatory_doc" | "process" | undefined;
+    traces_from?: string[] | undefined;
+    traces_to?: string[] | undefined;
+}>;
+type RequirementType = z.infer<typeof RequirementTypeSchema>;
+type RequirementFormat = z.infer<typeof RequirementFormatSchema>;
+type RequirementFulfillmentType = z.infer<typeof RequirementFulfillmentTypeSchema>;
+type RequirementFrontmatter = z.infer<typeof RequirementFrontmatterSchema>;
+
+/**
+ * Zod schemas for Test document types (protocols and reports).
+ */
+
+declare const TestProtocolFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"test_protocol">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "test_protocol";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    type: "test_protocol";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+declare const TestPhaseSchema: z.ZodEnum<["verification", "production"]>;
+declare const TestReportFrontmatterSchema: z.ZodObject<{
+    type: z.ZodLiteral<"test_report">;
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    release_version: z.ZodOptional<z.ZodString>;
+    test_phase: z.ZodOptional<z.ZodEnum<["verification", "production"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "test_report";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    release_version?: string | undefined;
+    test_phase?: "verification" | "production" | undefined;
+}, {
+    type: "test_report";
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    release_version?: string | undefined;
+    test_phase?: "verification" | "production" | undefined;
+}>;
+type TestPhase = z.infer<typeof TestPhaseSchema>;
+type TestProtocolFrontmatter = z.infer<typeof TestProtocolFrontmatterSchema>;
+type TestReportFrontmatter = z.infer<typeof TestReportFrontmatterSchema>;
+
+/**
+ * Zod schema for the pactosigna.yml repository config file.
+ *
+ * This file lives at the root of a connected device repository and
+ * declares device identity, safety classification, regulatory
+ * classification metadata, and release review signing requirements.
+ * The sync engine reads it and applies the config to the Device entity.
+ */
+
+declare const ReleaseReviewConfigSchema: z.ZodObject<{
+    required_departments: z.ZodArray<z.ZodString, "many">;
+    final_approver: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    final_approver: string;
+    required_departments: string[];
+}, {
+    final_approver: string;
+    required_departments: string[];
+}>;
+type ReleaseReviewConfig = z.infer<typeof ReleaseReviewConfigSchema>;
+declare const RepoConfigSchema: z.ZodObject<{
+    device: z.ZodObject<{
+        name: z.ZodString;
+        safety_class: z.ZodEnum<["A", "B", "C"]>;
+        classification: z.ZodOptional<z.ZodObject<{
+            eu: z.ZodOptional<z.ZodString>;
+            us: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            eu?: string | undefined;
+            us?: string | undefined;
+        }, {
+            eu?: string | undefined;
+            us?: string | undefined;
+        }>>;
+        udi_device_identifier: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        safety_class: "A" | "B" | "C";
+        name: string;
+        classification?: {
+            eu?: string | undefined;
+            us?: string | undefined;
+        } | undefined;
+        udi_device_identifier?: string | undefined;
+    }, {
+        safety_class: "A" | "B" | "C";
+        name: string;
+        classification?: {
+            eu?: string | undefined;
+            us?: string | undefined;
+        } | undefined;
+        udi_device_identifier?: string | undefined;
+    }>;
+    release_review: z.ZodOptional<z.ZodObject<{
+        required_departments: z.ZodArray<z.ZodString, "many">;
+        final_approver: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        final_approver: string;
+        required_departments: string[];
+    }, {
+        final_approver: string;
+        required_departments: string[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    device: {
+        safety_class: "A" | "B" | "C";
+        name: string;
+        classification?: {
+            eu?: string | undefined;
+            us?: string | undefined;
+        } | undefined;
+        udi_device_identifier?: string | undefined;
+    };
+    release_review?: {
+        final_approver: string;
+        required_departments: string[];
+    } | undefined;
+}, {
+    device: {
+        safety_class: "A" | "B" | "C";
+        name: string;
+        classification?: {
+            eu?: string | undefined;
+            us?: string | undefined;
+        } | undefined;
+        udi_device_identifier?: string | undefined;
+    };
+    release_review?: {
+        final_approver: string;
+        required_departments: string[];
+    } | undefined;
+}>;
+type RepoConfig = z.infer<typeof RepoConfigSchema>;
+
+/**
+ * Change Management Schemas
+ *
+ * Frontmatter schemas and parsed body types for release_plan, design_review,
+ * and release_notes document types. These types are consumed by the sync
+ * engine body parsers and the gap detection system.
+ */
+
+declare const ReleasePlanFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"release_plan">>;
+    status: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    version: z.ZodOptional<z.ZodString>;
+    target_date: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    type?: "release_plan" | undefined;
+    status?: string | undefined;
+    version?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    target_date?: string | undefined;
+}, {
+    id: string;
+    title: string;
+    type?: "release_plan" | undefined;
+    status?: string | undefined;
+    version?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    target_date?: string | undefined;
+}>;
+type ReleasePlanFrontmatter = z.infer<typeof ReleasePlanFrontmatterSchema>;
+declare const DesignReviewFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"design_review">>;
+    status: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Optional link to a Release Plan document (e.g. "RP-001") */
+    release_plan: z.ZodOptional<z.ZodString>;
+    /** Acknowledged suspected links — one-up/one-down neighbor analysis */
+    suspected_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        triggered_by: z.ZodString;
+        neighbors: z.ZodArray<z.ZodObject<{
+            document: z.ZodString;
+            direction: z.ZodEnum<["upstream", "downstream"]>;
+            disposition: z.ZodEnum<["included_in_release", "not_impacted"]>;
+            /** Required when disposition is 'not_impacted' */
+            rationale: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            disposition: "included_in_release" | "not_impacted";
+            document: string;
+            direction: "upstream" | "downstream";
+            rationale?: string | undefined;
+        }, {
+            disposition: "included_in_release" | "not_impacted";
+            document: string;
+            direction: "upstream" | "downstream";
+            rationale?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        triggered_by: string;
+        neighbors: {
+            disposition: "included_in_release" | "not_impacted";
+            document: string;
+            direction: "upstream" | "downstream";
+            rationale?: string | undefined;
+        }[];
+    }, {
+        triggered_by: string;
+        neighbors: {
+            disposition: "included_in_release" | "not_impacted";
+            document: string;
+            direction: "upstream" | "downstream";
+            rationale?: string | undefined;
+        }[];
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    type?: "design_review" | undefined;
+    status?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    release_plan?: string | undefined;
+    suspected_links?: {
+        triggered_by: string;
+        neighbors: {
+            disposition: "included_in_release" | "not_impacted";
+            document: string;
+            direction: "upstream" | "downstream";
+            rationale?: string | undefined;
+        }[];
+    }[] | undefined;
+}, {
+    id: string;
+    title: string;
+    type?: "design_review" | undefined;
+    status?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    release_plan?: string | undefined;
+    suspected_links?: {
+        triggered_by: string;
+        neighbors: {
+            disposition: "included_in_release" | "not_impacted";
+            document: string;
+            direction: "upstream" | "downstream";
+            rationale?: string | undefined;
+        }[];
+    }[] | undefined;
+}>;
+type DesignReviewFrontmatter = z.infer<typeof DesignReviewFrontmatterSchema>;
+declare const ReleaseNotesAudienceSchema: z.ZodEnum<["customer", "technical"]>;
+type ReleaseNotesAudience = z.infer<typeof ReleaseNotesAudienceSchema>;
+declare const ReleaseNotesFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"release_notes">>;
+    status: z.ZodEnum<["draft", "in_review", "approved", "effective", "archived", "example"]>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    audience: z.ZodEnum<["customer", "technical"]>;
+    release_version: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    release_version: string;
+    audience: "customer" | "technical";
+    type?: "release_notes" | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    status: "draft" | "in_review" | "approved" | "effective" | "archived" | "example";
+    id: string;
+    title: string;
+    release_version: string;
+    audience: "customer" | "technical";
+    type?: "release_notes" | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type ReleaseNotesFrontmatter = z.infer<typeof ReleaseNotesFrontmatterSchema>;
+
+/**
+ * Retention policy schema for FDA 21 CFR Part 11 §11.10(c) and ESIGN §7001(d) compliance.
+ *
+ * Organizations must retain regulated records for a configurable period.
+ * The default retention period is 10 years, which covers most FDA regulatory
+ * requirements. Per-record-type overrides allow stricter retention where needed.
+ */
+declare const RetentionPolicySchema: z.ZodObject<{
+    /** Default retention period in years for all record types */
+    defaultPeriodYears: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Optional per-record-type overrides (e.g., { "release": 15, "signature": 20 }).
+     * Keys are record type identifiers; values are retention periods in years.
+     */
+    byRecordType: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    defaultPeriodYears: number;
+    byRecordType?: Record<string, number> | undefined;
+}, {
+    defaultPeriodYears?: number | undefined;
+    byRecordType?: Record<string, number> | undefined;
+}>;
+type RetentionPolicy = z.infer<typeof RetentionPolicySchema>;
+/**
+ * Determines whether a record is still within its retention period.
+ *
+ * A record is within retention if the current date is strictly before the
+ * retention expiry date (createdAt + retentionYears). Records exactly at
+ * the boundary are considered expired (retention period has elapsed).
+ *
+ * @param createdAt - The date the record was created
+ * @param retentionYears - The retention period in years
+ * @param now - Optional current date for testing (defaults to new Date())
+ * @returns true if the record must be retained (cannot be deleted)
+ */
+declare function isWithinRetentionPeriod(createdAt: Date, retentionYears: number, now?: Date): boolean;
+/**
+ * Resolves the effective retention period for a given record type.
+ *
+ * Checks the per-record-type overrides first, then falls back to the
+ * default period. If no policy is provided, returns the regulatory
+ * default of 10 years.
+ *
+ * @param policy - The organization's retention policy (or undefined)
+ * @param recordType - The type of record to look up
+ * @returns The retention period in years
+ */
+declare function getEffectiveRetentionYears(policy: RetentionPolicy | undefined, recordType: string): number;
+
+/**
+ * Internal Audit Management Schemas (ISO 13485 §8.2.2)
+ *
+ * Frontmatter schemas for audit_schedule and audit_report document types.
+ * Consumed by the sync engine for validation and gap detection.
+ */
+
+declare const AuditFindingClassificationSchema: z.ZodEnum<["observation", "minor_nc", "major_nc"]>;
+type AuditFindingClassification = z.infer<typeof AuditFindingClassificationSchema>;
+declare const AuditStatusSchema: z.ZodEnum<["planned", "in_progress", "completed", "cancelled"]>;
+type AuditStatus = z.infer<typeof AuditStatusSchema>;
+declare const PlannedAuditEntrySchema: z.ZodObject<{
+    audit_id: z.ZodString;
+    process_area: z.ZodString;
+    clause: z.ZodOptional<z.ZodString>;
+    planned_date: z.ZodString;
+    auditor: z.ZodString;
+    status: z.ZodEnum<["planned", "in_progress", "completed", "cancelled"]>;
+}, "strip", z.ZodTypeAny, {
+    auditor: string;
+    status: "in_progress" | "completed" | "cancelled" | "planned";
+    audit_id: string;
+    process_area: string;
+    planned_date: string;
+    clause?: string | undefined;
+}, {
+    auditor: string;
+    status: "in_progress" | "completed" | "cancelled" | "planned";
+    audit_id: string;
+    process_area: string;
+    planned_date: string;
+    clause?: string | undefined;
+}>;
+type PlannedAuditEntry = z.infer<typeof PlannedAuditEntrySchema>;
+declare const AuditScheduleFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"audit_schedule">>;
+    status: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    cycle_year: z.ZodNumber;
+    audits: z.ZodArray<z.ZodObject<{
+        audit_id: z.ZodString;
+        process_area: z.ZodString;
+        clause: z.ZodOptional<z.ZodString>;
+        planned_date: z.ZodString;
+        auditor: z.ZodString;
+        status: z.ZodEnum<["planned", "in_progress", "completed", "cancelled"]>;
+    }, "strip", z.ZodTypeAny, {
+        auditor: string;
+        status: "in_progress" | "completed" | "cancelled" | "planned";
+        audit_id: string;
+        process_area: string;
+        planned_date: string;
+        clause?: string | undefined;
+    }, {
+        auditor: string;
+        status: "in_progress" | "completed" | "cancelled" | "planned";
+        audit_id: string;
+        process_area: string;
+        planned_date: string;
+        clause?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    cycle_year: number;
+    audits: {
+        auditor: string;
+        status: "in_progress" | "completed" | "cancelled" | "planned";
+        audit_id: string;
+        process_area: string;
+        planned_date: string;
+        clause?: string | undefined;
+    }[];
+    type?: "audit_schedule" | undefined;
+    status?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}, {
+    id: string;
+    title: string;
+    cycle_year: number;
+    audits: {
+        auditor: string;
+        status: "in_progress" | "completed" | "cancelled" | "planned";
+        audit_id: string;
+        process_area: string;
+        planned_date: string;
+        clause?: string | undefined;
+    }[];
+    type?: "audit_schedule" | undefined;
+    status?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+}>;
+type AuditScheduleFrontmatter = z.infer<typeof AuditScheduleFrontmatterSchema>;
+declare const AuditFindingSchema: z.ZodObject<{
+    finding_id: z.ZodString;
+    classification: z.ZodEnum<["observation", "minor_nc", "major_nc"]>;
+    description: z.ZodString;
+    capa_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    classification: "observation" | "minor_nc" | "major_nc";
+    finding_id: string;
+    description: string;
+    capa_id?: string | undefined;
+}, {
+    classification: "observation" | "minor_nc" | "major_nc";
+    finding_id: string;
+    description: string;
+    capa_id?: string | undefined;
+}>;
+type AuditFinding = z.infer<typeof AuditFindingSchema>;
+declare const AuditReportFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"audit_report">>;
+    status: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    audit_date: z.ZodString;
+    audit_id: z.ZodOptional<z.ZodString>;
+    process_area: z.ZodString;
+    clause: z.ZodOptional<z.ZodString>;
+    auditor: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        finding_id: z.ZodString;
+        classification: z.ZodEnum<["observation", "minor_nc", "major_nc"]>;
+        description: z.ZodString;
+        capa_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        classification: "observation" | "minor_nc" | "major_nc";
+        finding_id: string;
+        description: string;
+        capa_id?: string | undefined;
+    }, {
+        classification: "observation" | "minor_nc" | "major_nc";
+        finding_id: string;
+        description: string;
+        capa_id?: string | undefined;
+    }>, "many">;
+    findings_major: z.ZodOptional<z.ZodNumber>;
+    findings_minor: z.ZodOptional<z.ZodNumber>;
+    findings_observations: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    auditor: string;
+    id: string;
+    title: string;
+    process_area: string;
+    audit_date: string;
+    findings: {
+        classification: "observation" | "minor_nc" | "major_nc";
+        finding_id: string;
+        description: string;
+        capa_id?: string | undefined;
+    }[];
+    type?: "audit_report" | undefined;
+    status?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    audit_id?: string | undefined;
+    clause?: string | undefined;
+    findings_major?: number | undefined;
+    findings_minor?: number | undefined;
+    findings_observations?: number | undefined;
+}, {
+    auditor: string;
+    id: string;
+    title: string;
+    process_area: string;
+    audit_date: string;
+    findings: {
+        classification: "observation" | "minor_nc" | "major_nc";
+        finding_id: string;
+        description: string;
+        capa_id?: string | undefined;
+    }[];
+    type?: "audit_report" | undefined;
+    status?: string | undefined;
+    author?: string | undefined;
+    reviewers?: string[] | undefined;
+    approvers?: string[] | undefined;
+    audit_id?: string | undefined;
+    clause?: string | undefined;
+    findings_major?: number | undefined;
+    findings_minor?: number | undefined;
+    findings_observations?: number | undefined;
+}>;
+type AuditReportFrontmatter = z.infer<typeof AuditReportFrontmatterSchema>;
+
+declare const ManagementReviewAttendeeSchema: z.ZodObject<{
+    name: z.ZodString;
+    role: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    role: string;
+}, {
+    name: string;
+    role: string;
+}>;
+type ManagementReviewAttendee = z.infer<typeof ManagementReviewAttendeeSchema>;
+declare const ManagementReviewFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"management_review">>;
+    version: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["draft", "scheduled", "completed"]>>;
+    review_date: z.ZodString;
+    review_period: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        to: string;
+        from: string;
+    }, {
+        to: string;
+        from: string;
+    }>;
+    attendees: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        role: string;
+    }, {
+        name: string;
+        role: string;
+    }>, "many">;
+    data_snapshot_date: z.ZodOptional<z.ZodString>;
+    next_review_date: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    review_date: string;
+    review_period: {
+        to: string;
+        from: string;
+    };
+    attendees: {
+        name: string;
+        role: string;
+    }[];
+    type?: "management_review" | undefined;
+    status?: "draft" | "completed" | "scheduled" | undefined;
+    version?: string | undefined;
+    data_snapshot_date?: string | undefined;
+    next_review_date?: string | undefined;
+}, {
+    id: string;
+    title: string;
+    review_date: string;
+    review_period: {
+        to: string;
+        from: string;
+    };
+    attendees: {
+        name: string;
+        role: string;
+    }[];
+    type?: "management_review" | undefined;
+    status?: "draft" | "completed" | "scheduled" | undefined;
+    version?: string | undefined;
+    data_snapshot_date?: string | undefined;
+    next_review_date?: string | undefined;
+}>;
+type ManagementReviewFrontmatter = z.infer<typeof ManagementReviewFrontmatterSchema>;
+
+/**
+ * Document type constants for QMS and Device bounded contexts.
+ *
+ * QMS documents are company-wide quality procedures.
+ * Device documents are product-specific documentation.
+ */
+declare const QMS_DOCUMENT_TYPES: readonly ["sop", "policy", "work_instruction", "supplier", "audit_schedule", "audit_report", "management_review"];
+declare const DEVICE_DOCUMENT_TYPES: readonly ["user_need", "requirement", "architecture", "detailed_design", "test_protocol", "test_report", "usability_risk", "software_risk", "security_risk", "hazardous_situation", "harm", "haz_soe_software", "haz_soe_security", "hazard_category", "usability_plan", "use_specification", "task_analysis", "usability_evaluation", "summative_evaluation", "risk_management_plan", "software_development_plan", "software_maintenance_plan", "soup_register", "anomaly", "cybersecurity_plan", "sbom", "clinical_evaluation_plan", "clinical_evaluation_report", "post_market_surveillance_plan", "post_market_feedback", "labeling", "product_development_plan", "intended_use", "release_plan", "design_review", "release_notes", "software_test_plan"];
+type QmsDocumentType = (typeof QMS_DOCUMENT_TYPES)[number];
+type DeviceDocumentType = (typeof DEVICE_DOCUMENT_TYPES)[number];
+/**
+ * Change document types that have standalone sign-off flows.
+ * These are filtered out of the generic Documents page and shown
+ * in their own dedicated navigation sections.
+ */
+declare const CHANGE_DOCUMENT_TYPES: readonly ["design_review", "release_plan"];
+type ChangeDocumentType = (typeof CHANGE_DOCUMENT_TYPES)[number];
+/**
+ * Check if a document type is a change document with standalone sign-off
+ */
+declare function isChangeDocumentType(type: string): type is ChangeDocumentType;
+/**
+ * Check if a document type belongs to QMS context
+ */
+declare function isQmsDocumentType(type: string): type is QmsDocumentType;
+/**
+ * Check if a document type belongs to Device context
+ */
+declare function isDeviceDocumentType(type: string): type is DeviceDocumentType;
+
+/**
+ * Human-readable labels for document types
+ */
+declare const DOCUMENT_TYPES: Record<DocumentType, string>;
+/**
+ * Human-readable labels for link types
+ */
+declare const LINK_TYPES: Record<LinkType, string>;
+/**
+ * Required H2 sections per document type.
+ *
+ * The sync engine checks documents against this registry and generates
+ * 'missing_section' gaps (severity: warning) for any absent headings.
+ * Matching is case-insensitive and uses substring containment
+ * (so "## Scope (v2.1)" matches "Scope").
+ *
+ * Generic mechanism: any document type can register required sections here.
+ */
+declare const REQUIRED_SECTIONS: Partial<Record<DocumentType, string[]>>;
 
 /**
  * Schema Map — maps document type strings to their Zod frontmatter schemas.
@@ -87,4 +1887,4 @@ declare function validateDirectory(dirPath: string, options?: {
     exclude?: string[];
 }): DirectoryValidationResult;
 
-export { type DirectoryValidationResult, SCHEMA_MAP, type StructureError, type StructureWarning, type ValidationResult, getSchemaForDocumentType, validateDirectory, validateDocument };
+export { AcceptabilityStatusSchema, type AnomalyCategory, AnomalyCategorySchema, type AnomalyDisposition, AnomalyDispositionSchema, type AnomalyFrontmatter, AnomalyFrontmatterSchema, type AnomalySeverity, AnomalySeveritySchema, type AuditFinding, type AuditFindingClassification, AuditFindingClassificationSchema, AuditFindingSchema, type AuditReportFrontmatter, AuditReportFrontmatterSchema, type AuditScheduleFrontmatter, AuditScheduleFrontmatterSchema, type AuditStatus, AuditStatusSchema, CHANGE_DOCUMENT_TYPES, type ChangeDocumentType, type ClinicalEvaluationPlanFrontmatter, ClinicalEvaluationPlanFrontmatterSchema, type ClinicalEvaluationReportFrontmatter, ClinicalEvaluationReportFrontmatterSchema, type CybersecurityPlanFrontmatter, CybersecurityPlanFrontmatterSchema, DEVICE_DOCUMENT_TYPES, DOCUMENT_TYPES, type DesignReviewFrontmatter, DesignReviewFrontmatterSchema, type DeviceDocumentType, type DirectoryValidationResult, DocumentStatusSchema, DocumentTypeSchema, type HarmFrontmatter, HarmFrontmatterSchema, type HazardCategoryFrontmatter, HazardCategoryFrontmatterSchema, type HazardFrontmatter, HazardFrontmatterSchema, type HazardousSituationFrontmatter, HazardousSituationFrontmatterSchema, type IntendedUseFrontmatter, IntendedUseFrontmatterSchema, LINK_TYPES, type LabelingFrontmatter, LabelingFrontmatterSchema, LinkTypeSchema, type ManagementReviewAttendee, ManagementReviewAttendeeSchema, type ManagementReviewFrontmatter, ManagementReviewFrontmatterSchema, type Mitigation, MitigationSchema, MitigationTargetSchema, type PlannedAuditEntry, PlannedAuditEntrySchema, PostMarketFeedbackCategorySchema, type PostMarketFeedbackFrontmatter, PostMarketFeedbackFrontmatterSchema, PostMarketFeedbackSeveritySchema, type PostMarketSurveillancePlanFrontmatter, PostMarketSurveillancePlanFrontmatterSchema, type ProductDevelopmentPlanFrontmatter, ProductDevelopmentPlanFrontmatterSchema, QMS_DOCUMENT_TYPES, type QmsDocumentType, REQUIRED_SECTIONS, RegulatoryFrameworkSchema, type ReleaseNotesAudience, ReleaseNotesAudienceSchema, type ReleaseNotesFrontmatter, ReleaseNotesFrontmatterSchema, type ReleasePlanFrontmatter, ReleasePlanFrontmatterSchema, type ReleaseReviewConfig, ReleaseReviewConfigSchema, type RepoConfig, RepoConfigSchema, type RequirementFormat, RequirementFormatSchema, type RequirementFrontmatter, RequirementFrontmatterSchema, type RequirementFulfillmentType, RequirementFulfillmentTypeSchema, type RequirementType, RequirementTypeSchema, type RetentionPolicy, RetentionPolicySchema, type RiskDocumentStatus, RiskDocumentStatusSchema, type RiskEntryFrontmatter, RiskEntryFrontmatterSchema, RiskGapCodeSchema, RiskGapSeveritySchema, type RiskManagementPlanFrontmatter, RiskManagementPlanFrontmatterSchema, type RiskMatrixConfig, RiskMatrixConfigSchema, SCHEMA_MAP, SafetyClassSchema, type SbomFrontmatter, SbomFrontmatterSchema, type SoftwareDevelopmentPlanFrontmatter, SoftwareDevelopmentPlanFrontmatterSchema, type SoftwareMaintenancePlanFrontmatter, SoftwareMaintenancePlanFrontmatterSchema, type SoftwareTestPlanFrontmatter, SoftwareTestPlanFrontmatterSchema, type SoupRegisterFrontmatter, SoupRegisterFrontmatterSchema, type StructureError, type StructureWarning, type SummativeEvaluationFrontmatter, SummativeEvaluationFrontmatterSchema, type TaskAnalysisFrontmatter, TaskAnalysisFrontmatterSchema, type TestPhase, TestPhaseSchema, type TestProtocolFrontmatter, TestProtocolFrontmatterSchema, type TestReportFrontmatter, TestReportFrontmatterSchema, type UsabilityEvaluationFrontmatter, UsabilityEvaluationFrontmatterSchema, type UsabilityPlanFrontmatter, UsabilityPlanFrontmatterSchema, type UseSpecificationFrontmatter, UseSpecificationFrontmatterSchema, type UserNeedFrontmatter, UserNeedFrontmatterSchema, type UserNeedPriority, UserNeedPrioritySchema, type ValidationResult, getEffectiveRetentionYears, getSchemaForDocumentType, isChangeDocumentType, isDeviceDocumentType, isQmsDocumentType, isWithinRetentionPeriod, validateDirectory, validateDocument };