@pdtf/schemas 3.6.0-36 → 3.6.0-37

package/src/schemas/v3/pdtf-transaction.json

@@ -1677,6 +1677,45 @@
                           }
                         ]
                       },
+                      "titleRestrictions": {
+                        "title": "Are there any known restrictions on the title?",
+                        "type": "object",
+                        "properties": {
+                          "yesNo": {
+                            "type": "string",
+                            "title": "",
+                            "enum": [
+                              "Yes",
+                              "No"
+                            ]
+                          }
+                        },
+                        "oneOf": [
+                          {
+                            "properties": {
+                              "yesNo": {
+                                "enum": [
+                                  "No"
+                                ]
+                              }
+                            }
+                          },
+                          {
+                            "properties": {
+                              "yesNo": {
+                                "enum": [
+                                  "Yes"
+                                ]
+                              },
+                              "details": {
+                                "title": "Details",
+                                "type": "string",
+                                "minLength": 1
+                              }
+                            }
+                          }
+                        ]
+                      },
                       "wholeFreeholdForSale": {
                         "title": "Is the entire freehold being sold?",
                         "type": "object",
@@ -8430,6 +8469,20 @@
                 }
               ]
             },
+            "droppedKerbAccess": {
+              "title": "Is there a dropped kerb access to parking?",
+              "type": "object",
+              "properties": {
+                "yesNo": {
+                  "type": "string",
+                  "title": "",
+                  "enum": [
+                    "Yes",
+                    "No"
+                  ]
+                }
+              }
+            },
             "electricVehicleChargingPoint": {
               "title": "Is there an electric vehicle charging point belonging to the property?",
               "type": "object",
@@ -18009,6 +18062,25 @@
                                 "Attached",
                                 "To follow"
                               ]
+                            },
+                            "associatedCost": {
+                              "title": "Associated costs of leased solar panels",
+                              "type": "object",
+                              "properties": {
+                                "amount": {
+                                  "title": "Associated costs of leased solar panels if any (£)",
+                                  "type": "number"
+                                },
+                                "frequency": {
+                                  "title": "Payment frequency if costs are associated",
+                                  "type": "string",
+                                  "enum": [
+                                    "Per month",
+                                    "Per year",
+                                    "Not applicable"
+                                  ]
+                                }
+                              }
                             }
                           }
                         }
@@ -20952,6 +21024,45 @@
                     }
                   ]
                 },
+                "privateRightOfWay": {
+                  "title": "A private right of way through and/or across your house, buildings or land",
+                  "type": "object",
+                  "properties": {
+                    "yesNo": {
+                      "type": "string",
+                      "title": "",
+                      "enum": [
+                        "Yes",
+                        "No"
+                      ]
+                    }
+                  },
+                  "oneOf": [
+                    {
+                      "properties": {
+                        "yesNo": {
+                          "enum": [
+                            "No"
+                          ]
+                        }
+                      }
+                    },
+                    {
+                      "properties": {
+                        "yesNo": {
+                          "enum": [
+                            "Yes"
+                          ]
+                        },
+                        "details": {
+                          "title": "Please provide details",
+                          "type": "string",
+                          "minLength": 1
+                        }
+                      }
+                    }
+                  ]
+                },
                 "rightsOfLight": {
                   "title": "Rights of light",
                   "type": "object",
@@ -21600,6 +21711,45 @@
                 }
               }
             },
+            "stormFireFloodDamage": {
+              "title": "Has the property ever suffered storm, fire or flood damage?",
+              "type": "object",
+              "properties": {
+                "yesNo": {
+                  "type": "string",
+                  "title": "",
+                  "enum": [
+                    "Yes",
+                    "No"
+                  ]
+                }
+              },
+              "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "Yes"
+                      ]
+                    },
+                    "details": {
+                      "title": "Please provide details",
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  }
+                }
+              ]
+            },
             "radon": {
               "title": "Radon",
               "type": "object",

package/src/schemas/v3/skeleton.json

@@ -289,6 +289,10 @@
             "details": "string",
             "amount": "number"
           },
+          "titleRestrictions": {
+            "yesNo": "variant",
+            "details": "string"
+          },
           "wholeFreeholdForSale": {
             "yesNo": "variant",
             "details": "string"
@@ -1229,6 +1233,9 @@
         "yesNo": "variant",
         "details": "string"
       },
+      "droppedKerbAccess": {
+        "yesNo": "string"
+      },
       "electricVehicleChargingPoint": {
         "yesNo": "variant",
         "chargerDetails": "string",
@@ -2386,7 +2393,11 @@
         "panelsOwnedOutright": {
           "yesNo": "variant",
           "details": "string",
-          "attachments": "string"
+          "attachments": "string",
+          "associatedCost": {
+            "amount": "number",
+            "frequency": "string"
+          }
         },
         "panelProviderLease": {
           "yesNo": "variant",
@@ -2736,6 +2747,10 @@
           "details": "string",
           "attachments": "string"
         },
+        "privateRightOfWay": {
+          "yesNo": "variant",
+          "details": "string"
+        },
         "rightsOfLight": {
           "yesNo": "variant",
           "details": "string"
@@ -2815,6 +2830,10 @@
           "details": "string"
         }
       },
+      "stormFireFloodDamage": {
+        "yesNo": "variant",
+        "details": "string"
+      },
       "radon": {
         "radonRisk": {
           "riskIndicator": "string",

package/src/tests/v3/extensionOverlays.test.js

@@ -165,6 +165,15 @@ describe("Extension Overlays", () => {
         "sc",
         "pc",
         "ph", // SEF25
+        "dk",
+        "rw",
+        "sd",
+        "lc",
+        "wg",
+        "ic",
+        "nd",
+        "mi",
+        "tr", // SEF25 (new)
       ];
 
       expect(Object.keys(extensionOverlays).sort()).toEqual(
@@ -642,6 +651,25 @@ describe("Extension Overlays", () => {
         expect(result).toBe(true);
       });
 
+      test("should validate private water with no associated costs", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+          details: "Private borehole",
+          associatedCost: {
+            amount: 0,
+            frequency: "Not applicable",
+          },
+        });
+
+        expect(result).toBe(true);
+      });
+
       test("should require associated cost for private water supply", () => {
         const validator = getSubschemaValidator(
           "/propertyPack/waterAndDrainage/water/mainsWater",
@@ -957,5 +985,374 @@ describe("Extension Overlays", () => {
         );
       });
     });
+
+    describe("Dropped kerb (dk)", () => {
+      test("should validate Yes answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/droppedKerbAccess",
+          schemaId,
+          ["dk"]
+        );
+        expect(validator({ yesNo: "Yes" })).toBe(true);
+      });
+
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/droppedKerbAccess",
+          schemaId,
+          ["dk"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should reject invalid value", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/droppedKerbAccess",
+          schemaId,
+          ["dk"]
+        );
+        expect(validator({ yesNo: "Maybe" })).toBe(false);
+      });
+
+      test("should not be required without dk overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const parking = schema.properties?.propertyPack?.properties?.parking;
+        expect(parking?.required || []).not.toContain("droppedKerbAccess");
+      });
+
+      test("should be required with dk overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["dk"]);
+        const parking = schema.properties?.propertyPack?.properties?.parking;
+        expect(parking?.required).toContain("droppedKerbAccess");
+      });
+    });
+
+    describe("Private right of way (rw)", () => {
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Neighbour has access through garden" })).toBe(true);
+      });
+
+      test("should reject Yes without details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "Yes" })).toBe(false);
+      });
+
+      test("should reject Yes with empty details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "Yes", details: "" })).toBe(false);
+      });
+
+      test("should not be required without rw overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const rights = schema.properties?.propertyPack?.properties?.rightsAndInformalArrangements
+          ?.properties?.rightsOrArrangements;
+        expect(rights?.required || []).not.toContain("privateRightOfWay");
+      });
+
+      test("should be required with rw overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["rw"]);
+        const rights = schema.properties?.propertyPack?.properties?.rightsAndInformalArrangements
+          ?.properties?.rightsOrArrangements;
+        expect(rights?.required).toContain("privateRightOfWay");
+      });
+    });
+
+    describe("Storm/fire/flood damage (sd)", () => {
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/environmentalIssues/stormFireFloodDamage",
+          schemaId,
+          ["sd"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/environmentalIssues/stormFireFloodDamage",
+          schemaId,
+          ["sd"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Flood damage in 2020" })).toBe(true);
+      });
+
+      test("should reject Yes without details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/environmentalIssues/stormFireFloodDamage",
+          schemaId,
+          ["sd"]
+        );
+        expect(validator({ yesNo: "Yes" })).toBe(false);
+      });
+
+      test("should not be required without sd overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const env = schema.properties?.propertyPack?.properties?.environmentalIssues;
+        expect(env?.required || []).not.toContain("stormFireFloodDamage");
+      });
+
+      test("should be required with sd overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["sd"]);
+        const env = schema.properties?.propertyPack?.properties?.environmentalIssues;
+        expect(env?.required).toContain("stormFireFloodDamage");
+      });
+    });
+
+    describe("Solar lease costs (lc)", () => {
+      test("should validate Not applicable frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 0, frequency: "Not applicable" })).toBe(true);
+      });
+
+      test("should validate amount and frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 75, frequency: "Per month" })).toBe(true);
+      });
+
+      test("should reject missing amount", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ frequency: "Per month" })).toBe(false);
+      });
+
+      test("should reject missing frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 75 })).toBe(false);
+      });
+
+      test("should reject invalid frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 75, frequency: "Weekly" })).toBe(false);
+      });
+    });
+
+    describe("Warranties and guarantees (wg)", () => {
+      const warrantyCategoryPaths = [
+        { path: "newHomeWarranty", ref: "W1.1" },
+        { path: "roofingWork", ref: "W1.2" },
+        { path: "dampProofingTreatment", ref: "W1.3" },
+        { path: "centralHeatingAndorPlumbing", ref: "W1.4" },
+        { path: "electricalRepairOrInstallation", ref: "W1.5" },
+        { path: "subsidenceWork", ref: "W1.6" },
+        { path: "otherGuarantees", ref: "W1.7" },
+      ];
+
+      test("should have ntsRef on all warranty categories when wg overlay loaded", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5", "wg"]);
+        const warranties =
+          schema.properties?.propertyPack?.properties?.guaranteesWarrantiesAndIndemnityInsurances;
+
+        // Warranty fields are in oneOf[1] (hasValidGuaranteesOrWarranties = Yes)
+        const yesBranch = warranties.oneOf[1];
+
+        warrantyCategoryPaths.forEach(({ path, ref }) => {
+          expect(yesBranch.properties[path]?.ntsRef).toBe(ref);
+        });
+      });
+
+      test("should mark warranty categories as required when wg overlay loaded", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5", "wg"]);
+        const warranties =
+          schema.properties?.propertyPack?.properties?.guaranteesWarrantiesAndIndemnityInsurances;
+
+        const yesBranch = warranties.oneOf[1];
+        warrantyCategoryPaths.forEach(({ path }) => {
+          expect(yesBranch.required).toContain(path);
+        });
+      });
+
+      test("should not require warranty categories without any overlay", () => {
+        const schema = getTransactionSchema(schemaId, []);
+        const warranties =
+          schema.properties?.propertyPack?.properties?.guaranteesWarrantiesAndIndemnityInsurances;
+
+        const yesBranch = warranties.oneOf[1];
+        // Without any overlay, warranty categories should not be in required
+        expect(yesBranch.required || []).not.toContain("newHomeWarranty");
+        expect(yesBranch.required || []).not.toContain("electricalRepairOrInstallation");
+      });
+    });
+
+    describe("Insurance claims (ic)", () => {
+      test("should mark insuranceClaims as required in isInsured=Yes branch", () => {
+        const schema = getTransactionSchema(schemaId, ["ic"]);
+        const insurance = schema.properties?.propertyPack?.properties?.insurance;
+        // oneOf[1] is isInsured=Yes
+        const yesBranch = insurance.oneOf[1];
+        expect(yesBranch?.required).toContain("insuranceClaims");
+      });
+
+      test("should validate insuranceClaims No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/insurance/insuranceClaims",
+          schemaId,
+          ["baspiV5", "ic"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate insuranceClaims Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/insurance/insuranceClaims",
+          schemaId,
+          ["baspiV5", "ic"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Storm damage claim in 2019" })).toBe(true);
+      });
+    });
+
+    describe("Neighbour development (nd)", () => {
+      test("should add ntsRef to neighbourDevelopment", () => {
+        const schema = getTransactionSchema(schemaId, ["nd"]);
+        const nd = schema.properties?.propertyPack?.properties?.notices
+          ?.properties?.neighbourDevelopment;
+        expect(nd?.ntsRef).toBe("N1.1");
+      });
+
+      test("should add ntsRef via nd overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["nd"]);
+        const notices = schema.properties?.propertyPack?.properties?.notices;
+        expect(notices?.ntsRef).toBe("N1");
+      });
+
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/notices/neighbourDevelopment",
+          schemaId,
+          ["baspiV5", "nd"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+    });
+
+    describe("Other material issue (mi)", () => {
+      test("should mark otherMaterialIssue as required", () => {
+        const schema = getTransactionSchema(schemaId, ["mi"]);
+        const additional = schema.properties?.propertyPack?.properties?.additionalInformation;
+        expect(additional?.required).toContain("otherMaterialIssue");
+      });
+
+      test("should not require otherMaterialIssue without mi overlay", () => {
+        const schema = getTransactionSchema(schemaId, []);
+        const additional = schema.properties?.propertyPack?.properties?.additionalInformation;
+        expect(additional?.required || []).not.toContain("otherMaterialIssue");
+      });
+
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/additionalInformation/otherMaterialIssue",
+          schemaId,
+          ["baspiV5", "mi"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/additionalInformation/otherMaterialIssue",
+          schemaId,
+          ["baspiV5", "mi"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Previous subsidence issues" })).toBe(true);
+      });
+    });
+
+    describe("Title restrictions (tr)", () => {
+      test("should require titleRestrictions in freehold branch with tr overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["tr"]);
+        const items = schema.properties?.propertyPack?.properties?.ownership
+          ?.properties?.ownershipsToBeTransferred?.items;
+        // oneOf[0] is Freehold
+        const freeholdBranch = items.oneOf[0];
+        expect(freeholdBranch?.properties?.titleRestrictions).toBeDefined();
+        expect(freeholdBranch?.required).toContain("titleRestrictions");
+      });
+
+      test("should not require titleRestrictions without tr overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const items = schema.properties?.propertyPack?.properties?.ownership
+          ?.properties?.ownershipsToBeTransferred?.items;
+        const freeholdBranch = items.oneOf[0];
+        expect(freeholdBranch?.required || []).not.toContain("titleRestrictions");
+      });
+
+      test("should have correct ntsRef", () => {
+        const schema = getTransactionSchema(schemaId, ["tr"]);
+        const items = schema.properties?.propertyPack?.properties?.ownership
+          ?.properties?.ownershipsToBeTransferred?.items;
+        const freeholdBranch = items.oneOf[0];
+        expect(freeholdBranch?.properties?.titleRestrictions?.ntsRef).toBe("T1.1");
+      });
+    });
+
+    describe("All SEF25 extensions combined", () => {
+      const allSef25 = ["sc", "pc", "ph", "dk", "rw", "sd", "lc", "wg", "ic", "nd", "mi", "tr"];
+
+      test("should load all SEF25 extensions together without error", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5", ...allSef25]);
+        expect(schema).toBeDefined();
+        expect(schema.properties?.propertyPack).toBeDefined();
+      });
+
+      test("should not interfere with existing NTS2 extensions when combined", () => {
+        const schema = getTransactionSchema(schemaId, ["nts2025", ...allSef25]);
+
+        // NTS2 fields still work
+        const si = schema.properties?.propertyPack?.properties?.specialistIssues;
+        expect(si?.properties?.wellsDitchesShaft?.ntsRef).toBe("H1.1");
+
+        // New SEF25 fields present
+        const parking = schema.properties?.propertyPack?.properties?.parking?.properties;
+        expect(parking?.droppedKerbAccess).toBeDefined();
+
+        const env = schema.properties?.propertyPack?.properties?.environmentalIssues?.properties;
+        expect(env?.stormFireFloodDamage).toBeDefined();
+
+        const rights = schema.properties?.propertyPack?.properties?.rightsAndInformalArrangements
+          ?.properties?.rightsOrArrangements?.properties;
+        expect(rights?.privateRightOfWay).toBeDefined();
+      });
+    });
   });
 });