@vepler/sdk 6.1.0 → 6.8.0

package/src/sdk/models/shared/listing.ts

@@ -12,11 +12,19 @@ import * as openEnums from "../../types/enums.js";
 import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ImageCondition,
+  ImageCondition$inboundSchema,
+} from "./imagecondition.js";
 import { ListingImage, ListingImage$inboundSchema } from "./listingimage.js";
 import {
   ListingPriceChange,
   ListingPriceChange$inboundSchema,
 } from "./listingpricechange.js";
+import {
+  ObservedFeature,
+  ObservedFeature$inboundSchema,
+} from "./observedfeature.js";
 
 /**
  * Features the listing advertises.
@@ -46,6 +54,110 @@ export type ListingFeatures = {
   additionalProperties?: { [k: string]: any } | undefined;
 };
 
+/**
+ * The state of repair across the photographs as a whole. Null when too few photographs carry an assessment to summarise one.
+ */
+export type ListingCondition = {
+  /**
+   * Confidence in that assessment, from 0 to 1.
+   */
+  confidence?: number | undefined;
+  /**
+   * The state of repair the photographs suggest.
+   */
+  value?: ImageCondition | undefined;
+};
+
+/**
+ * How the photographs present the property, keyed by quality key. `virtually_staged` is worth reading before treating condition as evidence, because digitally added furniture changes how a room reads.
+ */
+export type Presentation = {
+  emptyRoom?: ObservedFeature | undefined;
+  furnished?: ObservedFeature | undefined;
+  virtuallyStaged?: ObservedFeature | undefined;
+  watermarkPresent?: ObservedFeature | undefined;
+};
+
+/**
+ * Spaces the photographs show, keyed by scene key, each with the evidence behind it. A key is absent when no photograph supports it, which is not the same as the property lacking that space.
+ */
+export type Spaces = {
+  communal?: ObservedFeature | undefined;
+  communalCorridor?: ObservedFeature | undefined;
+  communalGarden?: ObservedFeature | undefined;
+  communalLobby?: ObservedFeature | undefined;
+  exterior?: ObservedFeature | undefined;
+  exteriorAerial?: ObservedFeature | undefined;
+  exteriorFrontElevation?: ObservedFeature | undefined;
+  exteriorRearElevation?: ObservedFeature | undefined;
+  exteriorStreet?: ObservedFeature | undefined;
+  interior?: ObservedFeature | undefined;
+  interiorAttic?: ObservedFeature | undefined;
+  interiorBasement?: ObservedFeature | undefined;
+  interiorBathroom?: ObservedFeature | undefined;
+  interiorBathroomCloakroom?: ObservedFeature | undefined;
+  interiorBathroomEnsuite?: ObservedFeature | undefined;
+  interiorBathroomShowerRoom?: ObservedFeature | undefined;
+  interiorBedroom?: ObservedFeature | undefined;
+  interiorConservatory?: ObservedFeature | undefined;
+  interiorDiningRoom?: ObservedFeature | undefined;
+  interiorDressingRoom?: ObservedFeature | undefined;
+  interiorGamesRoom?: ObservedFeature | undefined;
+  interiorGarageInterior?: ObservedFeature | undefined;
+  interiorGym?: ObservedFeature | undefined;
+  interiorHallway?: ObservedFeature | undefined;
+  interiorKitchen?: ObservedFeature | undefined;
+  interiorKitchenDiner?: ObservedFeature | undefined;
+  interiorKitchenLiving?: ObservedFeature | undefined;
+  interiorLanding?: ObservedFeature | undefined;
+  interiorLibrary?: ObservedFeature | undefined;
+  interiorLivingRoom?: ObservedFeature | undefined;
+  interiorPoolRoom?: ObservedFeature | undefined;
+  interiorPorch?: ObservedFeature | undefined;
+  interiorSauna?: ObservedFeature | undefined;
+  interiorStairs?: ObservedFeature | undefined;
+  interiorStorage?: ObservedFeature | undefined;
+  interiorStudy?: ObservedFeature | undefined;
+  interiorUtilityRoom?: ObservedFeature | undefined;
+  interiorWineCellar?: ObservedFeature | undefined;
+  interiorWorkshop?: ObservedFeature | undefined;
+  nonProperty?: ObservedFeature | undefined;
+  outdoorSpace?: ObservedFeature | undefined;
+  outdoorSpaceBalcony?: ObservedFeature | undefined;
+  outdoorSpaceDriveway?: ObservedFeature | undefined;
+  outdoorSpaceGarden?: ObservedFeature | undefined;
+  outdoorSpaceOutbuilding?: ObservedFeature | undefined;
+  outdoorSpacePatio?: ObservedFeature | undefined;
+  outdoorSpacePool?: ObservedFeature | undefined;
+  outdoorSpaceTerrace?: ObservedFeature | undefined;
+};
+
+/**
+ * What the listing's photographs show, as distinct from what its text advertises. Null until the gallery has been analysed.
+ */
+export type ObservedFeatures = {
+  /**
+   * The state of repair across the photographs as a whole. Null when too few photographs carry an assessment to summarise one.
+   */
+  condition?: ListingCondition | null | undefined;
+  /**
+   * How many of the listing's images these values were drawn from.
+   */
+  imagesAnalysed?: number | undefined;
+  /**
+   * How the photographs present the property, keyed by quality key. `virtually_staged` is worth reading before treating condition as evidence, because digitally added furniture changes how a room reads.
+   */
+  presentation?: Presentation | undefined;
+  /**
+   * Spaces the photographs show, keyed by scene key, each with the evidence behind it. A key is absent when no photograph supports it, which is not the same as the property lacking that space.
+   */
+  spaces?: Spaces | undefined;
+  /**
+   * Release of the label vocabulary these values were produced against.
+   */
+  taxonomyVersion?: string | undefined;
+};
+
 /**
  * What the listing asks for the property.
  */
@@ -142,6 +254,10 @@ export type Listing = {
    * Identifier of this listing.
    */
   listingId?: string | undefined;
+  /**
+   * What the listing's photographs show, as distinct from what its text advertises. Null until the gallery has been analysed.
+   */
+  observedFeatures?: ObservedFeatures | null | undefined;
   /**
    * Every price this listing has been advertised at, starting with the first.
    */
@@ -219,6 +335,189 @@ export function listingFeaturesFromJSON(
   );
 }
 
+/** @internal */
+export const ListingCondition$inboundSchema: z.ZodType<
+  ListingCondition,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number().optional(),
+  value: ImageCondition$inboundSchema.optional(),
+});
+
+export function listingConditionFromJSON(
+  jsonString: string,
+): SafeParseResult<ListingCondition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListingCondition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListingCondition' from JSON`,
+  );
+}
+
+/** @internal */
+export const Presentation$inboundSchema: z.ZodType<
+  Presentation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  empty_room: ObservedFeature$inboundSchema.optional(),
+  furnished: ObservedFeature$inboundSchema.optional(),
+  virtually_staged: ObservedFeature$inboundSchema.optional(),
+  watermark_present: ObservedFeature$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "empty_room": "emptyRoom",
+    "virtually_staged": "virtuallyStaged",
+    "watermark_present": "watermarkPresent",
+  });
+});
+
+export function presentationFromJSON(
+  jsonString: string,
+): SafeParseResult<Presentation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Presentation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Presentation' from JSON`,
+  );
+}
+
+/** @internal */
+export const Spaces$inboundSchema: z.ZodType<Spaces, z.ZodTypeDef, unknown> = z
+  .object({
+    communal: ObservedFeature$inboundSchema.optional(),
+    "communal.corridor": ObservedFeature$inboundSchema.optional(),
+    "communal.garden": ObservedFeature$inboundSchema.optional(),
+    "communal.lobby": ObservedFeature$inboundSchema.optional(),
+    exterior: ObservedFeature$inboundSchema.optional(),
+    "exterior.aerial": ObservedFeature$inboundSchema.optional(),
+    "exterior.front_elevation": ObservedFeature$inboundSchema.optional(),
+    "exterior.rear_elevation": ObservedFeature$inboundSchema.optional(),
+    "exterior.street": ObservedFeature$inboundSchema.optional(),
+    interior: ObservedFeature$inboundSchema.optional(),
+    "interior.attic": ObservedFeature$inboundSchema.optional(),
+    "interior.basement": ObservedFeature$inboundSchema.optional(),
+    "interior.bathroom": ObservedFeature$inboundSchema.optional(),
+    "interior.bathroom.cloakroom": ObservedFeature$inboundSchema.optional(),
+    "interior.bathroom.ensuite": ObservedFeature$inboundSchema.optional(),
+    "interior.bathroom.shower_room": ObservedFeature$inboundSchema.optional(),
+    "interior.bedroom": ObservedFeature$inboundSchema.optional(),
+    "interior.conservatory": ObservedFeature$inboundSchema.optional(),
+    "interior.dining_room": ObservedFeature$inboundSchema.optional(),
+    "interior.dressing_room": ObservedFeature$inboundSchema.optional(),
+    "interior.games_room": ObservedFeature$inboundSchema.optional(),
+    "interior.garage_interior": ObservedFeature$inboundSchema.optional(),
+    "interior.gym": ObservedFeature$inboundSchema.optional(),
+    "interior.hallway": ObservedFeature$inboundSchema.optional(),
+    "interior.kitchen": ObservedFeature$inboundSchema.optional(),
+    "interior.kitchen_diner": ObservedFeature$inboundSchema.optional(),
+    "interior.kitchen_living": ObservedFeature$inboundSchema.optional(),
+    "interior.landing": ObservedFeature$inboundSchema.optional(),
+    "interior.library": ObservedFeature$inboundSchema.optional(),
+    "interior.living_room": ObservedFeature$inboundSchema.optional(),
+    "interior.pool_room": ObservedFeature$inboundSchema.optional(),
+    "interior.porch": ObservedFeature$inboundSchema.optional(),
+    "interior.sauna": ObservedFeature$inboundSchema.optional(),
+    "interior.stairs": ObservedFeature$inboundSchema.optional(),
+    "interior.storage": ObservedFeature$inboundSchema.optional(),
+    "interior.study": ObservedFeature$inboundSchema.optional(),
+    "interior.utility_room": ObservedFeature$inboundSchema.optional(),
+    "interior.wine_cellar": ObservedFeature$inboundSchema.optional(),
+    "interior.workshop": ObservedFeature$inboundSchema.optional(),
+    non_property: ObservedFeature$inboundSchema.optional(),
+    outdoor_space: ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.balcony": ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.driveway": ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.garden": ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.outbuilding": ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.patio": ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.pool": ObservedFeature$inboundSchema.optional(),
+    "outdoor_space.terrace": ObservedFeature$inboundSchema.optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "communal.corridor": "communalCorridor",
+      "communal.garden": "communalGarden",
+      "communal.lobby": "communalLobby",
+      "exterior.aerial": "exteriorAerial",
+      "exterior.front_elevation": "exteriorFrontElevation",
+      "exterior.rear_elevation": "exteriorRearElevation",
+      "exterior.street": "exteriorStreet",
+      "interior.attic": "interiorAttic",
+      "interior.basement": "interiorBasement",
+      "interior.bathroom": "interiorBathroom",
+      "interior.bathroom.cloakroom": "interiorBathroomCloakroom",
+      "interior.bathroom.ensuite": "interiorBathroomEnsuite",
+      "interior.bathroom.shower_room": "interiorBathroomShowerRoom",
+      "interior.bedroom": "interiorBedroom",
+      "interior.conservatory": "interiorConservatory",
+      "interior.dining_room": "interiorDiningRoom",
+      "interior.dressing_room": "interiorDressingRoom",
+      "interior.games_room": "interiorGamesRoom",
+      "interior.garage_interior": "interiorGarageInterior",
+      "interior.gym": "interiorGym",
+      "interior.hallway": "interiorHallway",
+      "interior.kitchen": "interiorKitchen",
+      "interior.kitchen_diner": "interiorKitchenDiner",
+      "interior.kitchen_living": "interiorKitchenLiving",
+      "interior.landing": "interiorLanding",
+      "interior.library": "interiorLibrary",
+      "interior.living_room": "interiorLivingRoom",
+      "interior.pool_room": "interiorPoolRoom",
+      "interior.porch": "interiorPorch",
+      "interior.sauna": "interiorSauna",
+      "interior.stairs": "interiorStairs",
+      "interior.storage": "interiorStorage",
+      "interior.study": "interiorStudy",
+      "interior.utility_room": "interiorUtilityRoom",
+      "interior.wine_cellar": "interiorWineCellar",
+      "interior.workshop": "interiorWorkshop",
+      "non_property": "nonProperty",
+      "outdoor_space": "outdoorSpace",
+      "outdoor_space.balcony": "outdoorSpaceBalcony",
+      "outdoor_space.driveway": "outdoorSpaceDriveway",
+      "outdoor_space.garden": "outdoorSpaceGarden",
+      "outdoor_space.outbuilding": "outdoorSpaceOutbuilding",
+      "outdoor_space.patio": "outdoorSpacePatio",
+      "outdoor_space.pool": "outdoorSpacePool",
+      "outdoor_space.terrace": "outdoorSpaceTerrace",
+    });
+  });
+
+export function spacesFromJSON(
+  jsonString: string,
+): SafeParseResult<Spaces, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Spaces$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Spaces' from JSON`,
+  );
+}
+
+/** @internal */
+export const ObservedFeatures$inboundSchema: z.ZodType<
+  ObservedFeatures,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  condition: z.nullable(z.lazy(() => ListingCondition$inboundSchema))
+    .optional(),
+  imagesAnalysed: z.number().int().optional(),
+  presentation: z.lazy(() => Presentation$inboundSchema).optional(),
+  spaces: z.lazy(() => Spaces$inboundSchema).optional(),
+  taxonomyVersion: z.string().optional(),
+});
+
+export function observedFeaturesFromJSON(
+  jsonString: string,
+): SafeParseResult<ObservedFeatures, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ObservedFeatures$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ObservedFeatures' from JSON`,
+  );
+}
+
 /** @internal */
 export const Pricing$inboundSchema: z.ZodType<Pricing, z.ZodTypeDef, unknown> =
   z.object({
@@ -297,6 +596,8 @@ export const Listing$inboundSchema: z.ZodType<Listing, z.ZodTypeDef, unknown> =
     floorPlanImages: z.array(ListingImage$inboundSchema).optional(),
     images: z.array(ListingImage$inboundSchema).optional(),
     listingId: z.string().optional(),
+    observedFeatures: z.nullable(z.lazy(() => ObservedFeatures$inboundSchema))
+      .optional(),
     priceChange: z.array(ListingPriceChange$inboundSchema).optional(),
     pricing: z.lazy(() => Pricing$inboundSchema).optional(),
     publishedDate: z.nullable(

package/src/sdk/models/shared/listingimage.ts

@@ -4,10 +4,66 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ImageDocumentClass,
+  ImageDocumentClass$inboundSchema,
+} from "./imagedocumentclass.js";
+import { ImageQuality, ImageQuality$inboundSchema } from "./imagequality.js";
+import {
+  ImageSceneLabel,
+  ImageSceneLabel$inboundSchema,
+} from "./imagescenelabel.js";
+
+/**
+ * The state of repair the photograph suggests. Null when no assessment is published for this image.
+ */
+export const ListingImageCondition = {
+  MoveInReady: "move_in_ready",
+  CosmeticallyDated: "cosmetically_dated",
+  RenovationNeeded: "renovation_needed",
+  Derelict: "derelict",
+} as const;
+/**
+ * The state of repair the photograph suggests. Null when no assessment is published for this image.
+ */
+export type ListingImageCondition = OpenEnum<typeof ListingImageCondition>;
+
+/**
+ * What this image is and what it shows. Null until the image has been analysed.
+ */
+export type Labels = {
+  condition?: ListingImageCondition | null | undefined;
+  /**
+   * What the image is, rather than what it shows. A `photo` is a photograph of the property or its surroundings; the other values are documents published alongside the photographs.
+   */
+  documentClass?: ImageDocumentClass | undefined;
+  /**
+   * How strongly the image supports its document class, from 0 to 1.
+   */
+  documentClassConfidence?: number | undefined;
+  /**
+   * How the photograph presents the property rather than what it shows. `virtually_staged` marks furniture added digitally, and `empty_room` marks an unfurnished space.
+   */
+  presentation?: Array<ImageQuality> | undefined;
+  /**
+   * The spaces the photograph shows, most specific first, each with its own confidence. Keys are hierarchical, so `interior.bathroom.ensuite` also implies `interior.bathroom` and `interior`. Empty for anything that is not a photograph.
+   */
+  scene?: Array<ImageSceneLabel> | undefined;
+  /**
+   * Release of the label vocabulary these values were produced against.
+   */
+  taxonomyVersion?: string | undefined;
+};
 
 export type ListingImage = {
+  /**
+   * What this image is and what it shows. Null until the image has been analysed.
+   */
+  labels?: Labels | null | undefined;
   /**
    * URL of a ready-made 640×480 WebP thumbnail of the same image.
    */
@@ -18,12 +74,41 @@ export type ListingImage = {
   url?: string | null | undefined;
 };
 
+/** @internal */
+export const ListingImageCondition$inboundSchema: z.ZodType<
+  ListingImageCondition,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ListingImageCondition);
+
+/** @internal */
+export const Labels$inboundSchema: z.ZodType<Labels, z.ZodTypeDef, unknown> = z
+  .object({
+    condition: z.nullable(ListingImageCondition$inboundSchema).optional(),
+    documentClass: ImageDocumentClass$inboundSchema.optional(),
+    documentClassConfidence: z.number().optional(),
+    presentation: z.array(ImageQuality$inboundSchema).optional(),
+    scene: z.array(ImageSceneLabel$inboundSchema).optional(),
+    taxonomyVersion: z.string().optional(),
+  });
+
+export function labelsFromJSON(
+  jsonString: string,
+): SafeParseResult<Labels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Labels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Labels' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListingImage$inboundSchema: z.ZodType<
   ListingImage,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  labels: z.nullable(z.lazy(() => Labels$inboundSchema)).optional(),
   thumbnailUrl: z.nullable(z.string()).optional(),
   url: z.nullable(z.string()).optional(),
 });

package/src/sdk/models/shared/mortgagecharge.ts

@@ -20,6 +20,10 @@ export const MortgageChargeStatus = {
 export type MortgageChargeStatus = OpenEnum<typeof MortgageChargeStatus>;
 
 export type MortgageCharge = {
+  /**
+   * Other title numbers the same charge is registered against, read from an `affecting also title …` clause. Empty when the charge affects only `titleAffected`.
+   */
+  alsoAffectsTitles: Array<string>;
   chargeDate: string;
   chargeHolder: TitleProprietor;
   /**
@@ -55,6 +59,7 @@ export const MortgageCharge$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  alsoAffectsTitles: z.array(z.string()),
   chargeDate: z.string(),
   chargeHolder: TitleProprietor$inboundSchema,
   dischargedDate: z.nullable(z.string()),

package/src/sdk/models/shared/observedfeature.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ObservedFeature = {
+  /**
+   * Confidence of the strongest supporting image, from 0 to 1.
+   */
+  confidence?: number | undefined;
+  /**
+   * How many photographs support the feature. This counts images, not rooms: three photographs of a bathroom do not mean three bathrooms.
+   */
+  imageCount?: number | undefined;
+  /**
+   * Whether the photographs support this feature at the published confidence.
+   */
+  present?: boolean | undefined;
+};
+
+/** @internal */
+export const ObservedFeature$inboundSchema: z.ZodType<
+  ObservedFeature,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number().optional(),
+  imageCount: z.number().int().optional(),
+  present: z.boolean().optional(),
+});
+
+export function observedFeatureFromJSON(
+  jsonString: string,
+): SafeParseResult<ObservedFeature, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ObservedFeature$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ObservedFeature' from JSON`,
+  );
+}

package/src/sdk/models/shared/othercharge.ts

@@ -12,13 +12,20 @@ export type OtherCharge = {
    * The kind of charge, as the register labels it.
    */
   chargeType: string;
+  /**
+   * The date the entry was made in the register (the entry's `(dd.mm.yyyy)` prefix). Null when the entry carries no registration date.
+   */
   date: string | null;
   /**
    * Plain-English explanation of what this charge means for the owner, written by a language model from the register entry.
    */
   effectOfCharge: string;
   /**
-   * The parties named in the original charge entry.
+   * The date of the deed the entry refers to (the conveyance, transfer, lease or charge that created it), when the entry states one. Null otherwise. Distinct from `date`, which is when the entry was registered.
+   */
+  instrumentDate: string | null;
+  /**
+   * The parties the entry names, verbatim, in the order the deed lists them. Empty when the entry names nobody. Never a placeholder: an entry that names parties and reports none here is an extraction defect, not a register fact.
    */
   originalParties: Array<string>;
   sourceEntryRef: string;
@@ -33,6 +40,7 @@ export const OtherCharge$inboundSchema: z.ZodType<
   chargeType: z.string(),
   date: z.nullable(z.string()),
   effectOfCharge: z.string(),
+  instrumentDate: z.nullable(z.string()),
   originalParties: z.array(z.string()),
   sourceEntryRef: z.string(),
 });

package/src/sdk/models/shared/titlecovenant.ts

@@ -8,7 +8,14 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type TitleCovenant = {
+  /**
+   * The date the entry was made in the register (the entry's `(dd.mm.yyyy)` prefix). Null when the entry carries no registration date.
+   */
   date: string | null;
+  /**
+   * The date of the deed the entry refers to (the conveyance, transfer, lease or charge that created it), when the entry states one. Null otherwise. Distinct from `date`, which is when the entry was registered.
+   */
+  instrumentDate: string | null;
   /**
    * The legal text, quoted verbatim from the register entry.
    */
@@ -31,6 +38,7 @@ export const TitleCovenant$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   date: z.nullable(z.string()),
+  instrumentDate: z.nullable(z.string()),
   rawText: z.string(),
   sourceEntryRef: z.string(),
   title: z.string(),

package/src/sdk/models/shared/titleextractionpayload.ts

@@ -18,6 +18,14 @@ import {
   TitleDocumentSummary$inboundSchema,
 } from "./titledocumentsummary.js";
 import { TitleNotice, TitleNotice$inboundSchema } from "./titlenotice.js";
+import {
+  TitlePricePaid,
+  TitlePricePaid$inboundSchema,
+} from "./titlepricepaid.js";
+import {
+  TitlePropertyRight,
+  TitlePropertyRight$inboundSchema,
+} from "./titlepropertyright.js";
 import {
   TitleProprietor,
   TitleProprietor$inboundSchema,
@@ -71,6 +79,9 @@ export type TitleExtractionPayload = {
    * The current owner, formatted as a single line ready to display.
    */
   currentOwnerDisplay: string;
+  /**
+   * The title's documents as they stood when the extraction ran. Document uploads run concurrently with extraction, so this is a snapshot: the API overlays the live document rows on every read, and a consumer must never treat a `pending` here as current.
+   */
   documents: Array<TitleDocumentSummary>;
   extractedAt: Date;
   /**
@@ -79,13 +90,21 @@ export type TitleExtractionPayload = {
   leaseTermDescription: string;
   notices: Array<TitleNotice>;
   ownership: Ownership;
+  /**
+   * The price-paid entry from the Proprietorship Register. Null when the register records none.
+   */
+  pricePaid: TitlePricePaid | null;
   promptVersion: string;
+  /**
+   * Every Property Register entry other than the estate description and the lease particulars: easements, party-wall provisions, exceptions. Empty when the A register has no such entries.
+   */
+  propertyRights: Array<TitlePropertyRight>;
   /**
    * The qualification entry, quoted verbatim from the register. Null on titles that carry no qualification.
    */
   qualification: string | null;
   /**
-   * The edition date of the register this extract was taken from, as an ISO 8601 timestamp.
+   * The instant the official copy states it shows the register at ("shows the entries on the register of title on 17 SEP 2026 at 12:56:56"), as an ISO 8601 UTC timestamp. Not our fetch clock.
    */
   registerAsOf: Date;
   registeredCharges: RegisteredCharges;
@@ -145,7 +164,9 @@ export const TitleExtractionPayload$inboundSchema: z.ZodType<
   leaseTermDescription: z.string(),
   notices: z.array(TitleNotice$inboundSchema),
   ownership: z.lazy(() => Ownership$inboundSchema),
+  pricePaid: z.nullable(TitlePricePaid$inboundSchema),
   promptVersion: z.string(),
+  propertyRights: z.array(TitlePropertyRight$inboundSchema),
   qualification: z.nullable(z.string()).default(null),
   registerAsOf: z.string().datetime({ offset: true }).transform(v =>
     new Date(v)

package/src/sdk/models/shared/titlenotice.ts

@@ -19,7 +19,14 @@ export const NoticeType = {
 export type NoticeType = OpenEnum<typeof NoticeType>;
 
 export type TitleNotice = {
+  /**
+   * The date the entry was made in the register (the entry's `(dd.mm.yyyy)` prefix). Null when the entry carries no registration date.
+   */
   date: string | null;
+  /**
+   * The date of the deed the entry refers to (the conveyance, transfer, lease or charge that created it), when the entry states one. Null otherwise. Distinct from `date`, which is when the entry was registered.
+   */
+  instrumentDate: string | null;
   noticeType: NoticeType;
   partyName: string | null;
   /**
@@ -51,6 +58,7 @@ export const TitleNotice$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   date: z.nullable(z.string()),
+  instrumentDate: z.nullable(z.string()),
   noticeType: NoticeType$inboundSchema,
   partyName: z.nullable(z.string()),
   rawText: z.string(),