@pdtf/schemas 3.6.0-30 → 3.6.0-32

package/src/schemas/v3/skeleton.json

@@ -166,7 +166,13 @@
       },
       "yearOfBuild": "integer",
       "isNewBuild": {
-        "yesNo": "string"
+        "yesNo": "variant",
+        "newBuildDetails": {
+          "snaggingCompletion": "string",
+          "adoptionStatus": "string",
+          "conversionConsent": "boolean",
+          "conversionQuality": "string"
+        }
       },
       "isHMO": "string",
       "isStudentAccommodation": "string",
@@ -289,6 +295,10 @@
             "details": "string",
             "amount": "number"
           },
+          "titleRestrictions": {
+            "yesNo": "variant",
+            "details": "string"
+          },
           "wholeFreeholdForSale": {
             "yesNo": "variant",
             "details": "string"
@@ -1229,6 +1239,9 @@
         "yesNo": "variant",
         "details": "string"
       },
+      "droppedKerbAccess": {
+        "yesNo": "string"
+      },
       "electricVehicleChargingPoint": {
         "yesNo": "variant",
         "chargerDetails": "string",
@@ -2386,7 +2399,12 @@
         "panelsOwnedOutright": {
           "yesNo": "variant",
           "details": "string",
-          "attachments": "string"
+          "attachments": "string",
+          "associatedCost": {
+            "hasCost": "variant",
+            "amount": "number",
+            "frequency": "string"
+          }
         },
         "panelProviderLease": {
           "yesNo": "variant",
@@ -2449,6 +2467,7 @@
           "yesNo": "variant",
           "details": "string",
           "associatedCost": {
+            "hasCost": "variant",
             "amount": "number",
             "frequency": "string"
           },
@@ -2511,17 +2530,19 @@
               },
               "dischargeCompliesWithGBR": "string"
             },
+            "dateDischargeCommenced": {},
+            "dateInstalled": "string",
             "dateReplaced": "string",
             "dateLastEmptied": "string",
             "supplier": "string",
             "makeModel": "string",
             "serviceProviderName": "string",
-            "dateInstalled": "string",
             "dateLastServiced": "string",
             "attachments": "string",
             "details": "string"
           },
           "associatedCost": {
+            "hasCost": "variant",
             "amount": "number",
             "frequency": "string"
           }
@@ -2735,6 +2756,10 @@
           "details": "string",
           "attachments": "string"
         },
+        "privateRightOfWay": {
+          "yesNo": "variant",
+          "details": "string"
+        },
         "rightsOfLight": {
           "yesNo": "variant",
           "details": "string"
@@ -2814,6 +2839,10 @@
           "details": "string"
         }
       },
+      "stormFireFloodDamage": {
+        "yesNo": "variant",
+        "details": "string"
+      },
       "radon": {
         "radonRisk": {
           "riskIndicator": "string",
@@ -3340,13 +3369,7 @@
     },
     "confirmationOfAccuracyByOwners": {
       "confirmWillProvideAdditionalDocumentation": "boolean",
-      "confirmInformationIsAccurate": "boolean",
-      "sellerSignatures": [
-        {
-          "name": "string",
-          "signedOn": "string"
-        }
-      ]
+      "confirmInformationIsAccurate": "boolean"
     },
     "saleReadyDeclarations": {
       "authorisedToActOnBehalfOfAllSellers": "boolean",

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(
@@ -486,9 +495,14 @@ describe("Extension Overlays", () => {
       const cost = noBranch?.properties?.associatedCost;
       expect(cost).toBeDefined();
       expect(cost.sef25Ref).toBe("U1.1");
-      expect(cost.required).toEqual(["amount", "frequency"]);
-      expect(cost.properties.amount.type).toBe("number");
-      expect(cost.properties.frequency.type).toBe("string");
+      expect(cost.required).toEqual(["hasCost"]);
+      expect(cost.properties.hasCost.type).toBe("string");
+      expect(cost.oneOf).toHaveLength(2);
+      // Yes branch should have amount and frequency
+      const yesBranch = cost.oneOf[1];
+      expect(yesBranch.properties.amount.type).toBe("number");
+      expect(yesBranch.properties.frequency.type).toBe("string");
+      expect(yesBranch.required).toEqual(["amount", "frequency"]);
     });
 
     test("should merge supply costs extension into mainsFoulDrainage No/Not known branch", () => {
@@ -504,7 +518,7 @@ describe("Extension Overlays", () => {
       const cost = noBranch?.properties?.associatedCost;
       expect(cost).toBeDefined();
       expect(cost.sef25Ref).toBe("U1.2");
-      expect(cost.required).toEqual(["amount", "frequency"]);
+      expect(cost.required).toEqual(["hasCost"]);
     });
 
     test("should merge parking permit cost and frequency into controlledParking Yes branch", () => {
@@ -634,6 +648,7 @@ describe("Extension Overlays", () => {
           yesNo: "No",
           details: "Private borehole",
           associatedCost: {
+            hasCost: "Yes",
             amount: 50,
             frequency: "Per month",
           },
@@ -642,6 +657,24 @@ 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: {
+            hasCost: "No",
+          },
+        });
+
+        expect(result).toBe(true);
+      });
+
       test("should require associated cost for private water supply", () => {
         const validator = getSubschemaValidator(
           "/propertyPack/waterAndDrainage/water/mainsWater",
@@ -669,6 +702,7 @@ describe("Extension Overlays", () => {
           yesNo: "No",
           details: "Borehole",
           associatedCost: {
+            hasCost: "Yes",
             amount: 100,
             frequency: "Weekly",
           },
@@ -688,6 +722,7 @@ describe("Extension Overlays", () => {
           yesNo: "No",
           details: "Borehole",
           associatedCost: {
+            hasCost: "Yes",
             amount: "fifty pounds",
             frequency: "Per month",
           },
@@ -707,6 +742,7 @@ describe("Extension Overlays", () => {
         const result = validator({
           yesNo: "No",
           associatedCost: {
+            hasCost: "Yes",
             amount: 200,
             frequency: "Per year",
           },
@@ -725,6 +761,7 @@ describe("Extension Overlays", () => {
         const result = validator({
           yesNo: "No",
           associatedCost: {
+            hasCost: "Yes",
             amount: 200,
             frequency: "Quarterly",
           },
@@ -957,5 +994,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 No costs", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ hasCost: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with amount and frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ hasCost: "Yes", amount: 75, frequency: "Per month" })).toBe(true);
+      });
+
+      test("should reject Yes without amount", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ hasCost: "Yes", frequency: "Per month" })).toBe(false);
+      });
+
+      test("should reject Yes without frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ hasCost: "Yes", amount: 75 })).toBe(false);
+      });
+
+      test("should reject invalid frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ hasCost: "Yes", 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 sef25Ref on all warranty categories in base schema", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        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]?.sef25Ref).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 sef25Ref to neighbourDevelopment", () => {
+        const schema = getTransactionSchema(schemaId, ["nd"]);
+        const nd = schema.properties?.propertyPack?.properties?.notices
+          ?.properties?.neighbourDevelopment;
+        expect(nd?.sef25Ref).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 sef25Ref", () => {
+        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?.sef25Ref).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();
+      });
+    });
   });
 });

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

@@ -1599,7 +1599,7 @@ describe("TA6 Edition 6 overlay", () => {
           mainsFoulDrainage: {
             yesNo: "No",
             offMainsDrainageSystem: {
-              offMainsDrainageSystemType: "Not known",
+              offMainsDrainageSystemType: "Other",
               otherConnectedProperties: { yesNo: "No" },
               plantOnOtherLand: { yesNo: "No" },
               plantRegistered: { yesNo: "No" },
@@ -2073,53 +2073,6 @@ describe("TA6 Edition 6 overlay", () => {
     });
   });
 
-  describe("Seller signatures validation", () => {
-    let validator;
-
-    beforeAll(() => {
-      validator = getSubschemaValidator(
-        "/propertyPack/confirmationOfAccuracyByOwners",
-        schemaId,
-        ["ta6ed6"]
-      );
-    });
-
-    test("confirmation with sellerSignatures is valid", () => {
-      const data = {
-        confirmInformationIsAccurate: true,
-        sellerSignatures: [
-          { name: "Jane Doe", signedOn: "2024-06-15" },
-          { name: "John Doe", signedOn: "2024-06-15" },
-        ],
-      };
-      expect(validator(data)).toBe(true);
-    });
-
-    test("sellerSignatures with single seller is valid", () => {
-      const data = {
-        confirmInformationIsAccurate: true,
-        sellerSignatures: [{ name: "Jane Doe", signedOn: "2024-06-15" }],
-      };
-      expect(validator(data)).toBe(true);
-    });
-
-    test("empty sellerSignatures array is valid", () => {
-      const data = {
-        confirmInformationIsAccurate: true,
-        sellerSignatures: [],
-      };
-      expect(validator(data)).toBe(true);
-    });
-
-    test("sellerSignatures with invalid date format is invalid", () => {
-      const data = {
-        confirmInformationIsAccurate: true,
-        sellerSignatures: [{ name: "Jane Doe", signedOn: "15/06/2024" }],
-      };
-      expect(validator(data)).toBe(false);
-    });
-  });
-
   describe("Previously broken discriminator sections now compile", () => {
     // These sections previously failed AJV compilation because their
     // discriminated properties were not in the required array of each