@vepler/sdk 2.50.3 → 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,6 +39,264 @@ 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
  */
@@ -144,6 +403,10 @@ export type PropertyDataApiSpatial = {
 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
    */
@@ -237,6 +500,196 @@ export type PropertyDataApi = {
   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({
@@ -392,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)

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

@@ -8,7 +8,7 @@ import { ClosedEnum } from "../../types/enums.js";
 /**
  * Comparison operator
  */
-export const Comparator = {
+export const PropertyQueryConditionComparator = {
   Eq: "eq",
   Ne: "ne",
   Gt: "gt",
@@ -24,14 +24,16 @@ export const Comparator = {
 /**
  * Comparison operator
  */
-export type Comparator = ClosedEnum<typeof Comparator>;
+export type PropertyQueryConditionComparator = ClosedEnum<
+  typeof PropertyQueryConditionComparator
+>;
 
 export type PropertyQueryCondition4 = string | number | boolean;
 
 /**
  * Value to compare against
  */
-export type Value =
+export type PropertyQueryConditionValue =
   | string
   | number
   | boolean
@@ -41,7 +43,7 @@ export type PropertyQueryCondition = {
   /**
    * Comparison operator
    */
-  comparator: Comparator;
+  comparator: PropertyQueryConditionComparator;
   /**
    * Field to filter on. Common fields: propertyType, propertyCategory ('residential' or 'commercial'), roomDetails.beds, pricing.currentSale, pricing.currentRent, build.totalFloorArea, epc.rating
    */
@@ -53,8 +55,9 @@ export type PropertyQueryCondition = {
 };
 
 /** @internal */
-export const Comparator$outboundSchema: z.ZodNativeEnum<typeof Comparator> = z
-  .nativeEnum(Comparator);
+export const PropertyQueryConditionComparator$outboundSchema: z.ZodNativeEnum<
+  typeof PropertyQueryConditionComparator
+> = z.nativeEnum(PropertyQueryConditionComparator);
 
 /** @internal */
 export type PropertyQueryCondition4$Outbound = string | number | boolean;
@@ -75,17 +78,17 @@ export function propertyQueryCondition4ToJSON(
 }
 
 /** @internal */
-export type Value$Outbound =
+export type PropertyQueryConditionValue$Outbound =
   | string
   | number
   | boolean
   | Array<string | number | boolean>;
 
 /** @internal */
-export const Value$outboundSchema: z.ZodType<
-  Value$Outbound,
+export const PropertyQueryConditionValue$outboundSchema: z.ZodType<
+  PropertyQueryConditionValue$Outbound,
   z.ZodTypeDef,
-  Value
+  PropertyQueryConditionValue
 > = z.union([
   z.string(),
   z.number(),
@@ -93,8 +96,14 @@ export const Value$outboundSchema: z.ZodType<
   z.array(z.union([z.string(), z.number(), z.boolean()])),
 ]);
 
-export function valueToJSON(value: Value): string {
-  return JSON.stringify(Value$outboundSchema.parse(value));
+export function propertyQueryConditionValueToJSON(
+  propertyQueryConditionValue: PropertyQueryConditionValue,
+): string {
+  return JSON.stringify(
+    PropertyQueryConditionValue$outboundSchema.parse(
+      propertyQueryConditionValue,
+    ),
+  );
 }
 
 /** @internal */
@@ -110,7 +119,7 @@ export const PropertyQueryCondition$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   PropertyQueryCondition
 > = z.object({
-  comparator: Comparator$outboundSchema,
+  comparator: PropertyQueryConditionComparator$outboundSchema,
   field: z.string(),
   value: z.union([
     z.string(),

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

@@ -13,14 +13,16 @@ import {
 /**
  * Logical operator
  */
-export const Operator = {
+export const PropertyQueryOperatorOperator = {
   And: "AND",
   Or: "OR",
 } as const;
 /**
  * Logical operator
  */
-export type Operator = ClosedEnum<typeof Operator>;
+export type PropertyQueryOperatorOperator = ClosedEnum<
+  typeof PropertyQueryOperatorOperator
+>;
 
 export type PropertyQueryOperator = {
   /**
@@ -30,12 +32,13 @@ export type PropertyQueryOperator = {
   /**
    * Logical operator
    */
-  operator: Operator;
+  operator: PropertyQueryOperatorOperator;
 };
 
 /** @internal */
-export const Operator$outboundSchema: z.ZodNativeEnum<typeof Operator> = z
-  .nativeEnum(Operator);
+export const PropertyQueryOperatorOperator$outboundSchema: z.ZodNativeEnum<
+  typeof PropertyQueryOperatorOperator
+> = z.nativeEnum(PropertyQueryOperatorOperator);
 
 /** @internal */
 export type PropertyQueryOperator$Outbound = {
@@ -50,7 +53,7 @@ export const PropertyQueryOperator$outboundSchema: z.ZodType<
   PropertyQueryOperator
 > = z.object({
   groups: z.array(PropertyQueryGroup$outboundSchema),
-  operator: Operator$outboundSchema,
+  operator: PropertyQueryOperatorOperator$outboundSchema,
 });
 
 export function propertyQueryOperatorToJSON(

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

@@ -18,7 +18,7 @@ import {
 /**
  * Comma-separated string or array of attributes to include in the response. Only the specified fields will be returned (plus locationId which is always included). Use this to reduce payload size by requesting only the data you need. Example: 'propertyId,pricing,address' or ['propertyId', 'pricing', 'address']
  */
-export type Attributes = string | Array<string>;
+export type PropertyQueryRequestAttributes = string | Array<string>;
 
 /**
  * Field to sort by (whitelisted fields only)
@@ -143,17 +143,23 @@ export type PropertyQueryRequest = {
 };
 
 /** @internal */
-export type Attributes$Outbound = string | Array<string>;
+export type PropertyQueryRequestAttributes$Outbound = string | Array<string>;
 
 /** @internal */
-export const Attributes$outboundSchema: z.ZodType<
-  Attributes$Outbound,
+export const PropertyQueryRequestAttributes$outboundSchema: z.ZodType<
+  PropertyQueryRequestAttributes$Outbound,
   z.ZodTypeDef,
-  Attributes
+  PropertyQueryRequestAttributes
 > = z.union([z.string(), z.array(z.string())]);
 
-export function attributesToJSON(attributes: Attributes): string {
-  return JSON.stringify(Attributes$outboundSchema.parse(attributes));
+export function propertyQueryRequestAttributesToJSON(
+  propertyQueryRequestAttributes: PropertyQueryRequestAttributes,
+): string {
+  return JSON.stringify(
+    PropertyQueryRequestAttributes$outboundSchema.parse(
+      propertyQueryRequestAttributes,
+    ),
+  );
 }
 
 /** @internal */