@vepler/sdk 2.46.0 → 2.57.3

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

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
 import * as openEnums from "../../types/enums.js";
 import { ClosedEnum, OpenEnum } from "../../types/enums.js";
@@ -38,23 +39,302 @@ import { SaleRecord, SaleRecord$inboundSchema } from "./salerecord.js";
 import { TenancyData, TenancyData$inboundSchema } from "./tenancydata.js";
 import { TenureData, TenureData$inboundSchema } from "./tenuredata.js";
 
+/**
+ * Address composition within this building
+ */
+export type AddressCount = {
+  /**
+   * Commercial address count
+   */
+  commercial?: number | null | undefined;
+  /**
+   * Other address count
+   */
+  other?: number | null | undefined;
+  /**
+   * Residential address count
+   */
+  residential?: number | null | undefined;
+  /**
+   * Total addressable units in this building
+   */
+  total?: number | null | undefined;
+};
+
+/**
+ * Basement presence
+ */
+export const Present = {
+  Present: "present",
+  Absent: "absent",
+  Unknown: "unknown",
+} as const;
+/**
+ * Basement presence
+ */
+export type Present = OpenEnum<typeof Present>;
+
+/**
+ * Whether the basement is self-contained with separate entrance
+ */
+export const SelfContained = {
+  Present: "present",
+  Absent: "absent",
+  Unknown: "unknown",
+} as const;
+/**
+ * Whether the basement is self-contained with separate entrance
+ */
+export type SelfContained = OpenEnum<typeof SelfContained>;
+
+/**
+ * Basement detection
+ */
+export type Basement = {
+  /**
+   * Basement presence
+   */
+  present?: Present | null | undefined;
+  /**
+   * Whether the basement is self-contained with separate entrance
+   */
+  selfContained?: SelfContained | null | undefined;
+};
+
+/**
+ * Construction age and materials (multi-source: OS NGD + EPC)
+ */
+export type Construction = {
+  /**
+   * Primary wall construction material
+   */
+  material?: string | null | undefined;
+  /**
+   * Construction age period band
+   */
+  period?: string | null | undefined;
+  /**
+   * Construction year (exact or approximate)
+   */
+  year?: number | null | undefined;
+};
+
+/**
+ * Roof area breakdown by orientation
+ */
+export type Area = {
+  /**
+   * East-facing roof area in m²
+   */
+  east?: number | null | undefined;
+  /**
+   * Flat roof area in m²
+   */
+  flat?: number | null | undefined;
+  /**
+   * Indeterminable roof area in m²
+   */
+  indeterminable?: number | null | undefined;
+  /**
+   * North-facing roof area in m²
+   */
+  north?: number | null | undefined;
+  /**
+   * Northeast-facing roof area in m²
+   */
+  northeast?: number | null | undefined;
+  /**
+   * Northwest-facing roof area in m²
+   */
+  northwest?: number | null | undefined;
+  /**
+   * Pitched roof area in m²
+   */
+  pitched?: number | null | undefined;
+  /**
+   * South-facing roof area in m²
+   */
+  south?: number | null | undefined;
+  /**
+   * Southeast-facing roof area in m²
+   */
+  southeast?: number | null | undefined;
+  /**
+   * Southwest-facing roof area in m²
+   */
+  southwest?: number | null | undefined;
+  /**
+   * Total roof surface area in m²
+   */
+  total?: number | null | undefined;
+  /**
+   * West-facing roof area in m²
+   */
+  west?: number | null | undefined;
+};
+
+/**
+ * Green/living roof presence detected from aerial survey
+ */
+export const GreenRoof = {
+  Present: "present",
+  Absent: "absent",
+  Unknown: "unknown",
+} as const;
+/**
+ * Green/living roof presence detected from aerial survey
+ */
+export type GreenRoof = OpenEnum<typeof GreenRoof>;
+
+/**
+ * Solar panel presence detected from aerial survey
+ */
+export const Solar = {
+  Present: "present",
+  Absent: "absent",
+  Unknown: "unknown",
+} as const;
+/**
+ * Solar panel presence detected from aerial survey
+ */
+export type Solar = OpenEnum<typeof Solar>;
+
+/**
+ * Roof analysis — shape, materials, directional area breakdown
+ */
+export type PropertyDataApiRoof = {
+  /**
+   * Roof area breakdown by orientation
+   */
+  area?: Area | null | undefined;
+  /**
+   * Green/living roof presence detected from aerial survey
+   */
+  greenRoof?: GreenRoof | null | undefined;
+  /**
+   * Primary roof covering material
+   */
+  material?: string | null | undefined;
+  /**
+   * Roof shape classification
+   */
+  shape?: string | null | undefined;
+  /**
+   * Solar panel presence detected from aerial survey
+   */
+  solar?: Solar | null | undefined;
+};
+
+/**
+ * Physical dimensions and characteristics
+ */
+export type Structure = {
+  /**
+   * Building connectivity type
+   */
+  connectivity?: string | null | undefined;
+  /**
+   * Number of above-ground floors
+   */
+  floors?: number | null | undefined;
+  /**
+   * Building footprint area in square metres
+   */
+  footprintAreaSqm?: number | null | undefined;
+  /**
+   * Maximum height above ground level in metres
+   */
+  heightMax?: number | null | undefined;
+  /**
+   * Physical state of the building
+   */
+  physicalState?: string | null | undefined;
+};
+
+/**
+ * Physical building data from OS NGD and EPC
+ */
+export type Building = {
+  /**
+   * Raw values per data source — stored only, not indexed
+   */
+  sourceValues?: { [k: string]: { [k: string]: any | null } } | undefined;
+  /**
+   * Address composition within this building
+   */
+  addressCount?: AddressCount | null | undefined;
+  /**
+   * Basement detection
+   */
+  basement?: Basement | null | undefined;
+  /**
+   * Construction age and materials (multi-source: OS NGD + EPC)
+   */
+  construction?: Construction | null | undefined;
+  /**
+   * Data sources that contributed to this building record
+   */
+  dataSources?: Array<string> | undefined;
+  /**
+   * OS NGD Building ID — links to the canonical building record in PostgreSQL
+   */
+  osid?: string | undefined;
+  /**
+   * Roof analysis — shape, materials, directional area breakdown
+   */
+  roof?: PropertyDataApiRoof | null | undefined;
+  /**
+   * Physical dimensions and characteristics
+   */
+  structure?: Structure | null | undefined;
+  /**
+   * OS NGD building type classification
+   */
+  type?: string | null | undefined;
+  /**
+   * Primary building use
+   */
+  use?: string | null | undefined;
+};
+
+/**
+ * Property charges including service charge and ground rent
+ */
 export type Charges = {
   groundRent?: ChargeHistory | null | undefined;
   serviceCharge?: ChargeHistory | null | undefined;
 };
 
+/**
+ * Accuracy level of property coordinates
+ */
 export const CoordinateConfidence = {
   High: "high",
   Medium: "medium",
   Low: "low",
 } as const;
+/**
+ * Accuracy level of property coordinates
+ */
 export type CoordinateConfidence = OpenEnum<typeof CoordinateConfidence>;
 
+/**
+ * Flood risk information
+ */
 export type FloodRisk = {
+  /**
+   * Flood risk level
+   */
   riskLevel?: string | undefined;
+  /**
+   * Suitability assessment
+   */
   suitability?: string | null | undefined;
 };
 
+/**
+ * Physical state of the property (derived from AddressBase Premium BLPU State)
+ */
 export const OccupancyStatus = {
   Planned: "planned",
   UnderConstruction: "under_construction",
@@ -62,12 +342,21 @@ export const OccupancyStatus = {
   Vacant: "vacant",
   Demolished: "demolished",
 } as const;
+/**
+ * Physical state of the property (derived from AddressBase Premium BLPU State)
+ */
 export type OccupancyStatus = OpenEnum<typeof OccupancyStatus>;
 
+/**
+ * Property category
+ */
 export const PropertyCategory = {
   Residential: "residential",
   Commercial: "commercial",
 } as const;
+/**
+ * Property category
+ */
 export type PropertyCategory = OpenEnum<typeof PropertyCategory>;
 
 export type PropertyDataApi2 = {
@@ -80,58 +369,327 @@ export type PropertyDataApi1 = {
   type: "Polygon";
 };
 
+/**
+ * Property boundary GeoJSON (Polygon or MultiPolygon)
+ */
 export type PropertyDataApiBoundary = PropertyDataApi1 | PropertyDataApi2;
 
+/**
+ * GeoJSON geometry type
+ */
 export const PropertyDataApiType = {
   Point: "Point",
 } as const;
+/**
+ * GeoJSON geometry type
+ */
 export type PropertyDataApiType = ClosedEnum<typeof PropertyDataApiType>;
 
 export type PropertyDataApiSpatial = {
+  /**
+   * Property boundary GeoJSON (Polygon or MultiPolygon)
+   */
   boundary?: PropertyDataApi1 | PropertyDataApi2 | undefined;
+  /**
+   * Coordinates as [longitude, latitude] following GeoJSON standard
+   */
   coordinates?: Array<number> | undefined;
+  /**
+   * GeoJSON geometry type
+   */
   type?: PropertyDataApiType | undefined;
 };
 
 export type PropertyDataApi = {
   address?: PropertyAddress | undefined;
   build?: BuildData | undefined;
+  /**
+   * Physical building data from OS NGD and EPC
+   */
+  building?: Building | null | undefined;
+  /**
+   * Property charges including service charge and ground rent
+   */
   charges?: Charges | undefined;
+  /**
+   * AddressBase Premium classification code (e.g., RD = Residential Dwelling, RH = HMO, C* = Commercial)
+   */
   classificationCode?: string | null | undefined;
+  /**
+   * Accuracy level of property coordinates
+   */
   coordinateConfidence?: CoordinateConfidence | null | undefined;
   councilTax?: CouncilTaxData | undefined;
   epc?: EPCData | undefined;
+  /**
+   * Flood risk information
+   */
   floodRisk?: FloodRisk | undefined;
+  /**
+   * Lease records for leasehold properties
+   */
   leases?: Array<Lease> | undefined;
+  /**
+   * Property listings with images and details
+   */
   listings?: Array<Listing> | undefined;
   /**
    * Location identifier (always returned)
    */
   locationId?: string | undefined;
   marketStatus?: MarketStatus | undefined;
+  /**
+   * Physical state of the property (derived from AddressBase Premium BLPU State)
+   */
   occupancyStatus?: OccupancyStatus | null | undefined;
+  /**
+   * Property overlays and designations
+   */
   overlays?: Array<string> | undefined;
+  /**
+   * Parent location identifier
+   */
   parentLocationId?: string | null | undefined;
+  /**
+   * Rent price change history
+   */
   priceChangeRent?: Array<PriceChange> | undefined;
+  /**
+   * Sale price change history
+   */
   priceChangeSale?: Array<PriceChange> | undefined;
   pricing?: PricingData | undefined;
+  /**
+   * Property category
+   */
   propertyCategory?: PropertyCategory | null | undefined;
+  /**
+   * Unique property identifier
+   */
   propertyId?: string | undefined;
   prosperity?: ProsperityData | undefined;
   refurbishment?: RefurbishmentData | undefined;
+  /**
+   * Related property IDs
+   */
   relationships?: Array<string> | undefined;
   roomDetails?: RoomDetails | undefined;
+  /**
+   * Historical sale records
+   */
   saleHistory?: Array<SaleRecord> | undefined;
+  /**
+   * SEO-friendly URL slug
+   */
   slug?: string | undefined;
+  /**
+   * Data source identifiers
+   */
   sources?: Array<string> | undefined;
   spatial?: PropertyDataApiSpatial | undefined;
+  /**
+   * Street identifiers
+   */
   streetIds?: Array<number> | undefined;
   tags?: PropertyTags | undefined;
   tenancy?: TenancyData | undefined;
   tenure?: TenureData | undefined;
+  /**
+   * Number of sub-units in multi-occupancy buildings (null for single units)
+   */
   unitCount?: number | null | undefined;
 };
 
+/** @internal */
+export const AddressCount$inboundSchema: z.ZodType<
+  AddressCount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  commercial: z.nullable(z.number().int()).optional(),
+  other: z.nullable(z.number().int()).optional(),
+  residential: z.nullable(z.number().int()).optional(),
+  total: z.nullable(z.number().int()).optional(),
+});
+
+export function addressCountFromJSON(
+  jsonString: string,
+): SafeParseResult<AddressCount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddressCount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddressCount' from JSON`,
+  );
+}
+
+/** @internal */
+export const Present$inboundSchema: z.ZodType<Present, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Present);
+
+/** @internal */
+export const SelfContained$inboundSchema: z.ZodType<
+  SelfContained,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SelfContained);
+
+/** @internal */
+export const Basement$inboundSchema: z.ZodType<
+  Basement,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  present: z.nullable(Present$inboundSchema).optional(),
+  selfContained: z.nullable(SelfContained$inboundSchema).optional(),
+});
+
+export function basementFromJSON(
+  jsonString: string,
+): SafeParseResult<Basement, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Basement$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Basement' from JSON`,
+  );
+}
+
+/** @internal */
+export const Construction$inboundSchema: z.ZodType<
+  Construction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  material: z.nullable(z.string()).optional(),
+  period: z.nullable(z.string()).optional(),
+  year: z.nullable(z.number().int()).optional(),
+});
+
+export function constructionFromJSON(
+  jsonString: string,
+): SafeParseResult<Construction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Construction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Construction' from JSON`,
+  );
+}
+
+/** @internal */
+export const Area$inboundSchema: z.ZodType<Area, z.ZodTypeDef, unknown> = z
+  .object({
+    east: z.nullable(z.number()).optional(),
+    flat: z.nullable(z.number()).optional(),
+    indeterminable: z.nullable(z.number()).optional(),
+    north: z.nullable(z.number()).optional(),
+    northeast: z.nullable(z.number()).optional(),
+    northwest: z.nullable(z.number()).optional(),
+    pitched: z.nullable(z.number()).optional(),
+    south: z.nullable(z.number()).optional(),
+    southeast: z.nullable(z.number()).optional(),
+    southwest: z.nullable(z.number()).optional(),
+    total: z.nullable(z.number()).optional(),
+    west: z.nullable(z.number()).optional(),
+  });
+
+export function areaFromJSON(
+  jsonString: string,
+): SafeParseResult<Area, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Area$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Area' from JSON`,
+  );
+}
+
+/** @internal */
+export const GreenRoof$inboundSchema: z.ZodType<
+  GreenRoof,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(GreenRoof);
+
+/** @internal */
+export const Solar$inboundSchema: z.ZodType<Solar, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Solar);
+
+/** @internal */
+export const PropertyDataApiRoof$inboundSchema: z.ZodType<
+  PropertyDataApiRoof,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  area: z.nullable(z.lazy(() => Area$inboundSchema)).optional(),
+  greenRoof: z.nullable(GreenRoof$inboundSchema).optional(),
+  material: z.nullable(z.string()).optional(),
+  shape: z.nullable(z.string()).optional(),
+  solar: z.nullable(Solar$inboundSchema).optional(),
+});
+
+export function propertyDataApiRoofFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyDataApiRoof, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PropertyDataApiRoof$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyDataApiRoof' from JSON`,
+  );
+}
+
+/** @internal */
+export const Structure$inboundSchema: z.ZodType<
+  Structure,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  connectivity: z.nullable(z.string()).optional(),
+  floors: z.nullable(z.number().int()).optional(),
+  footprintAreaSqm: z.nullable(z.number()).optional(),
+  heightMax: z.nullable(z.number()).optional(),
+  physicalState: z.nullable(z.string()).optional(),
+});
+
+export function structureFromJSON(
+  jsonString: string,
+): SafeParseResult<Structure, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Structure$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Structure' from JSON`,
+  );
+}
+
+/** @internal */
+export const Building$inboundSchema: z.ZodType<
+  Building,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _sourceValues: z.record(z.record(z.nullable(z.any()))).optional(),
+  addressCount: z.nullable(z.lazy(() => AddressCount$inboundSchema)).optional(),
+  basement: z.nullable(z.lazy(() => Basement$inboundSchema)).optional(),
+  construction: z.nullable(z.lazy(() => Construction$inboundSchema)).optional(),
+  dataSources: z.array(z.string()).optional(),
+  osid: z.string().optional(),
+  roof: z.nullable(z.lazy(() => PropertyDataApiRoof$inboundSchema)).optional(),
+  structure: z.nullable(z.lazy(() => Structure$inboundSchema)).optional(),
+  type: z.nullable(z.string()).optional(),
+  use: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_sourceValues": "sourceValues",
+  });
+});
+
+export function buildingFromJSON(
+  jsonString: string,
+): SafeParseResult<Building, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Building$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Building' from JSON`,
+  );
+}
+
 /** @internal */
 export const Charges$inboundSchema: z.ZodType<Charges, z.ZodTypeDef, unknown> =
   z.object({
@@ -287,6 +845,7 @@ export const PropertyDataApi$inboundSchema: z.ZodType<
 > = z.object({
   address: PropertyAddress$inboundSchema.optional(),
   build: BuildData$inboundSchema.optional(),
+  building: z.nullable(z.lazy(() => Building$inboundSchema)).optional(),
   charges: z.lazy(() => Charges$inboundSchema).optional(),
   classificationCode: z.nullable(z.string()).optional(),
   coordinateConfidence: z.nullable(CoordinateConfidence$inboundSchema)