@vepler/sdk 2.167.0 → 3.3.0

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

@@ -318,6 +318,20 @@ export const CoordinateConfidence = {
  */
 export type CoordinateConfidence = OpenEnum<typeof CoordinateConfidence>;
 
+/**
+ * Sovereign ISO 3166-1 alpha-2 country code (GB | IE). Distinct from the sub-national `address.country` nation slug.
+ */
+export const PropertyDataApiCountryCode = {
+  Gb: "GB",
+  Ie: "IE",
+} as const;
+/**
+ * Sovereign ISO 3166-1 alpha-2 country code (GB | IE). Distinct from the sub-national `address.country` nation slug.
+ */
+export type PropertyDataApiCountryCode = OpenEnum<
+  typeof PropertyDataApiCountryCode
+>;
+
 /**
  * Flood risk information
  */
@@ -332,6 +346,18 @@ export type FloodRisk = {
   suitability?: string | null | undefined;
 };
 
+/**
+ * Identity scheme that `locationId` holds: uprn for Great Britain (OS NGD), eircode for Ireland (future).
+ */
+export const IdScheme = {
+  Uprn: "uprn",
+  Eircode: "eircode",
+} as const;
+/**
+ * Identity scheme that `locationId` holds: uprn for Great Britain (OS NGD), eircode for Ireland (future).
+ */
+export type IdScheme = OpenEnum<typeof IdScheme>;
+
 /**
  * Physical state of the property (derived from AddressBase Premium BLPU State)
  */
@@ -359,14 +385,28 @@ export const PropertyCategory = {
  */
 export type PropertyCategory = OpenEnum<typeof PropertyCategory>;
 
+export const PropertyDataApiSchemasType = {
+  MultiPolygon: "MultiPolygon",
+} as const;
+export type PropertyDataApiSchemasType = ClosedEnum<
+  typeof PropertyDataApiSchemasType
+>;
+
 export type PropertyDataApi2 = {
-  coordinates: Array<Array<Array<Array<number>>>>;
-  type: "MultiPolygon";
+  coordinates?: Array<Array<Array<Array<number>>>> | undefined;
+  type?: PropertyDataApiSchemasType | undefined;
 };
 
+export const PropertyDataApiSchemasSpatialType = {
+  Polygon: "Polygon",
+} as const;
+export type PropertyDataApiSchemasSpatialType = ClosedEnum<
+  typeof PropertyDataApiSchemasSpatialType
+>;
+
 export type PropertyDataApi1 = {
-  coordinates: Array<Array<Array<number>>>;
-  type: "Polygon";
+  coordinates?: Array<Array<Array<number>>> | undefined;
+  type?: PropertyDataApiSchemasSpatialType | undefined;
 };
 
 /**
@@ -428,11 +468,19 @@ export type PropertyDataApi = {
    */
   coordinateConfidence?: CoordinateConfidence | null | undefined;
   councilTax?: CouncilTaxData | undefined;
+  /**
+   * Sovereign ISO 3166-1 alpha-2 country code (GB | IE). Distinct from the sub-national `address.country` nation slug.
+   */
+  countryCode?: PropertyDataApiCountryCode | undefined;
   epc?: EPCData | undefined;
   /**
    * Flood risk information
    */
   floodRisk?: FloodRisk | undefined;
+  /**
+   * Identity scheme that `locationId` holds: uprn for Great Britain (OS NGD), eircode for Ireland (future).
+   */
+  idScheme?: IdScheme | undefined;
   /**
    * Lease records for leasehold properties
    */
@@ -505,6 +553,10 @@ export type PropertyDataApi = {
    * Number of sub-units in multi-occupancy buildings (null for single units)
    */
   unitCount?: number | null | undefined;
+  /**
+   * Explicit Unique Property Reference Number (UPRN). Equals `locationId` for GB; null for IE.
+   */
+  uprn?: string | null | undefined;
 };
 
 /** @internal */
@@ -734,6 +786,13 @@ export const CoordinateConfidence$inboundSchema: z.ZodType<
   unknown
 > = openEnums.inboundSchema(CoordinateConfidence);
 
+/** @internal */
+export const PropertyDataApiCountryCode$inboundSchema: z.ZodType<
+  PropertyDataApiCountryCode,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PropertyDataApiCountryCode);
+
 /** @internal */
 export const FloodRisk$inboundSchema: z.ZodType<
   FloodRisk,
@@ -754,6 +813,13 @@ export function floodRiskFromJSON(
   );
 }
 
+/** @internal */
+export const IdScheme$inboundSchema: z.ZodType<
+  IdScheme,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(IdScheme);
+
 /** @internal */
 export const OccupancyStatus$inboundSchema: z.ZodType<
   OccupancyStatus,
@@ -768,14 +834,19 @@ export const PropertyCategory$inboundSchema: z.ZodType<
   unknown
 > = openEnums.inboundSchema(PropertyCategory);
 
+/** @internal */
+export const PropertyDataApiSchemasType$inboundSchema: z.ZodNativeEnum<
+  typeof PropertyDataApiSchemasType
+> = z.nativeEnum(PropertyDataApiSchemasType);
+
 /** @internal */
 export const PropertyDataApi2$inboundSchema: z.ZodType<
   PropertyDataApi2,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  coordinates: z.array(z.array(z.array(z.array(z.number())))),
-  type: z.literal("MultiPolygon"),
+  coordinates: z.array(z.array(z.array(z.array(z.number())))).optional(),
+  type: PropertyDataApiSchemasType$inboundSchema.optional(),
 });
 
 export function propertyDataApi2FromJSON(
@@ -788,14 +859,19 @@ export function propertyDataApi2FromJSON(
   );
 }
 
+/** @internal */
+export const PropertyDataApiSchemasSpatialType$inboundSchema: z.ZodNativeEnum<
+  typeof PropertyDataApiSchemasSpatialType
+> = z.nativeEnum(PropertyDataApiSchemasSpatialType);
+
 /** @internal */
 export const PropertyDataApi1$inboundSchema: z.ZodType<
   PropertyDataApi1,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  coordinates: z.array(z.array(z.array(z.number()))),
-  type: z.literal("Polygon"),
+  coordinates: z.array(z.array(z.array(z.number()))).optional(),
+  type: PropertyDataApiSchemasSpatialType$inboundSchema.optional(),
 });
 
 export function propertyDataApi1FromJSON(
@@ -874,8 +950,10 @@ export const PropertyDataApi$inboundSchema: z.ZodType<
   coordinateConfidence: z.nullable(CoordinateConfidence$inboundSchema)
     .optional(),
   councilTax: CouncilTaxData$inboundSchema.optional(),
+  countryCode: PropertyDataApiCountryCode$inboundSchema.optional(),
   epc: EPCData$inboundSchema.optional(),
   floodRisk: z.lazy(() => FloodRisk$inboundSchema).optional(),
+  idScheme: IdScheme$inboundSchema.optional(),
   leases: z.array(Lease$inboundSchema).optional(),
   listings: z.array(Listing$inboundSchema).optional(),
   locationId: z.string().optional(),
@@ -900,6 +978,7 @@ export const PropertyDataApi$inboundSchema: z.ZodType<
   tenancy: TenancyData$inboundSchema.optional(),
   tenure: TenureData$inboundSchema.optional(),
   unitCount: z.nullable(z.number().int()).optional(),
+  uprn: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "_provenance": "provenance",

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

@@ -122,6 +122,10 @@ export type PropertyQueryRequest = {
    * 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']
    */
   attributes?: string | Array<string> | undefined;
+  /**
+   * Optional sovereign-country hint (e.g. 'GB', 'IE'). Lenient free-string: normalised internally, never a hard filter. Only GB data exists today, so this is accepted as an ignored/GB-scoped hint; omitting it behaves exactly as today.
+   */
+  countryCode?: string | undefined;
   /**
    * Number of results to return per page
    */
@@ -216,6 +220,7 @@ export function propertyQueryRequestSortToJSON(
 export type PropertyQueryRequest$Outbound = {
   area: Array<PropertyAreaFilter$Outbound>;
   attributes?: string | Array<string> | undefined;
+  countryCode?: string | undefined;
   limit: number;
   offset: number;
   query: Array<PropertyQueryOperator$Outbound>;
@@ -231,6 +236,7 @@ export const PropertyQueryRequest$outboundSchema: z.ZodType<
 > = z.object({
   area: z.array(PropertyAreaFilter$outboundSchema),
   attributes: z.union([z.string(), z.array(z.string())]).optional(),
+  countryCode: z.string().optional(),
   limit: z.number().default(25),
   offset: z.number().default(0),
   query: z.array(PropertyQueryOperator$outboundSchema),

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

@@ -19,11 +19,11 @@ export type Provenance = {
   /**
    * Semantic version of the product pipeline that computed this response
    */
-  productVersion: string;
+  productVersion?: string | undefined;
   /**
    * ISO datetime when Vepler published this snapshot
    */
-  publishedAt: string;
+  publishedAt?: string | undefined;
   /**
    * Version of the shared scoring contract that produced this response's score/band. Present on air-quality envelopes; lets a consumer detect a substrate (/query) vs overlay (/point) scoring-table mismatch.
    */
@@ -31,11 +31,11 @@ export type Provenance = {
   /**
    * Identifier of the publish snapshot that produced this response
    */
-  snapshotId: string;
+  snapshotId?: string | undefined;
   /**
    * All upstream sources contributing to this response
    */
-  sources: Array<DataSourceRef>;
+  sources?: Array<DataSourceRef> | undefined;
 };
 
 /** @internal */
@@ -45,11 +45,11 @@ export const Provenance$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   asOf: z.string().optional(),
-  productVersion: z.string(),
-  publishedAt: z.string(),
+  productVersion: z.string().optional(),
+  publishedAt: z.string().optional(),
   scoringContractVersion: z.string().optional(),
-  snapshotId: z.string(),
-  sources: z.array(DataSourceRef$inboundSchema),
+  snapshotId: z.string().optional(),
+  sources: z.array(DataSourceRef$inboundSchema).optional(),
 });
 
 export function provenanceFromJSON(

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

@@ -0,0 +1,40 @@
+/*
+ * 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";
+import {
+  MortgageCharge,
+  MortgageCharge$inboundSchema,
+} from "./mortgagecharge.js";
+import { OtherCharge, OtherCharge$inboundSchema } from "./othercharge.js";
+
+export type RegisteredCharges = {
+  active: Array<MortgageCharge>;
+  discharged: Array<MortgageCharge>;
+  other: Array<OtherCharge>;
+};
+
+/** @internal */
+export const RegisteredCharges$inboundSchema: z.ZodType<
+  RegisteredCharges,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  active: z.array(MortgageCharge$inboundSchema),
+  discharged: z.array(MortgageCharge$inboundSchema),
+  other: z.array(OtherCharge$inboundSchema),
+});
+
+export function registeredChargesFromJSON(
+  jsonString: string,
+): SafeParseResult<RegisteredCharges, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RegisteredCharges$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RegisteredCharges' from JSON`,
+  );
+}

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

@@ -4,33 +4,96 @@
 
 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";
 
+/**
+ * Nation of the sale record
+ */
+export const SaleRecordNation = {
+  Eng: "ENG",
+  Wal: "WAL",
+  Sco: "SCO",
+  Nir: "NIR",
+} as const;
+/**
+ * Nation of the sale record
+ */
+export type SaleRecordNation = OpenEnum<typeof SaleRecordNation>;
+
+/**
+ * Price Paid category: A = standard market sale; B = additional transfer (repossession, portfolio, right-to-buy, CPO)
+ */
+export const PpdCategory = {
+  A: "A",
+  B: "B",
+} as const;
+/**
+ * Price Paid category: A = standard market sale; B = additional transfer (repossession, portfolio, right-to-buy, CPO)
+ */
+export type PpdCategory = OpenEnum<typeof PpdCategory>;
+
 export type SaleRecord = {
   /**
    * Sale price in GBP (whole pounds)
    */
-  amount: number;
+  amount?: number | undefined;
   /**
    * Sale completion date
    */
-  date: Date;
+  date?: Date | undefined;
+  /**
+   * Nation of the sale record
+   */
+  nation?: SaleRecordNation | undefined;
+  /**
+   * New-build sale flag from the price register
+   */
+  newBuild?: boolean | undefined;
+  /**
+   * Price Paid category: A = standard market sale; B = additional transfer (repossession, portfolio, right-to-buy, CPO)
+   */
+  ppdCategory?: PpdCategory | undefined;
   /**
    * Source identifier for this sale record
    */
-  sourceId: string;
+  sourceId?: string | undefined;
+  /**
+   * Tenure recorded on the sale
+   */
+  tenure?: string | undefined;
 };
 
+/** @internal */
+export const SaleRecordNation$inboundSchema: z.ZodType<
+  SaleRecordNation,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SaleRecordNation);
+
+/** @internal */
+export const PpdCategory$inboundSchema: z.ZodType<
+  PpdCategory,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PpdCategory);
+
 /** @internal */
 export const SaleRecord$inboundSchema: z.ZodType<
   SaleRecord,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  amount: z.number(),
-  date: z.string().datetime({ offset: true }).transform(v => new Date(v)),
-  sourceId: z.string(),
+  amount: z.number().optional(),
+  date: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  nation: SaleRecordNation$inboundSchema.optional(),
+  newBuild: z.boolean().optional(),
+  ppdCategory: PpdCategory$inboundSchema.optional(),
+  sourceId: z.string().optional(),
+  tenure: z.string().optional(),
 });
 
 export function saleRecordFromJSON(

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

@@ -90,6 +90,14 @@ export type SearchResponse = {
    * Object type identifier
    */
   object: SearchResponseObject;
+  /**
+   * Server-issued session id for the current candidate set, or null when no set was formed. Pass it back as the `search_id` query parameter on subsequent keystrokes to narrow within the same set without opening a new data fetch.
+   */
+  searchId?: string | null | undefined;
+  /**
+   * True when the results in this response are the COMPLETE match set for the query, so a client can narrow further keystrokes locally without another request. False when the response is a partial page or the match set was too large to fetch.
+   */
+  setComplete?: boolean | undefined;
   /**
    * Total number of items available
    */
@@ -150,11 +158,15 @@ export const SearchResponse$inboundSchema: z.ZodType<
   has_more: z.boolean(),
   metadata: z.lazy(() => Metadata$inboundSchema).optional(),
   object: SearchResponseObject$inboundSchema,
+  search_id: z.nullable(z.string()).optional(),
+  set_complete: z.boolean().optional(),
   total_count: z.number().optional(),
   url: z.string(),
 }).transform((v) => {
   return remap$(v, {
     "has_more": "hasMore",
+    "search_id": "searchId",
+    "set_complete": "setComplete",
     "total_count": "totalCount",
   });
 });

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

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  GeographicContext,
+  GeographicContext$inboundSchema,
+} from "./geographiccontext.js";
+
+/**
+ * WGS84 coordinates
+ */
+export type SearchRetrieveResponseCoordinates = {
+  /**
+   * Latitude in decimal degrees
+   */
+  lat: number;
+  /**
+   * Longitude in decimal degrees
+   */
+  lng: number;
+};
+
+export const SearchRetrieveResponseObject = {
+  Address: "address",
+} as const;
+export type SearchRetrieveResponseObject = ClosedEnum<
+  typeof SearchRetrieveResponseObject
+>;
+
+export type SearchRetrieveResponse = {
+  /**
+   * AddressBase classification code
+   */
+  classificationCode?: string | undefined;
+  /**
+   * WGS84 coordinates
+   */
+  coordinates?: SearchRetrieveResponseCoordinates | undefined;
+  /**
+   * County
+   */
+  county: string;
+  /**
+   * Single-line formatted address
+   */
+  formatted: string;
+  /**
+   * Geographic context (when include=geography)
+   */
+  geography?: GeographicContext | undefined;
+  /**
+   * Primary address line
+   */
+  line1: string;
+  /**
+   * Secondary address line
+   */
+  line2: string;
+  /**
+   * Tertiary address line
+   */
+  line3: string;
+  object: SearchRetrieveResponseObject;
+  /**
+   * Post town
+   */
+  postTown: string;
+  /**
+   * Postcode
+   */
+  postcode: string;
+  /**
+   * Echoes the `search_id` this retrieve was recorded against when a valid session was supplied; null when the retrieve was a direct resolve.
+   */
+  searchId: string | null;
+  /**
+   * Unique Property Reference Number
+   */
+  uprn: string;
+};
+
+/** @internal */
+export const SearchRetrieveResponseCoordinates$inboundSchema: z.ZodType<
+  SearchRetrieveResponseCoordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lng: z.number(),
+});
+
+export function searchRetrieveResponseCoordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchRetrieveResponseCoordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchRetrieveResponseCoordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchRetrieveResponseCoordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchRetrieveResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof SearchRetrieveResponseObject
+> = z.nativeEnum(SearchRetrieveResponseObject);
+
+/** @internal */
+export const SearchRetrieveResponse$inboundSchema: z.ZodType<
+  SearchRetrieveResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  classification_code: z.string().optional(),
+  coordinates: z.lazy(() => SearchRetrieveResponseCoordinates$inboundSchema)
+    .optional(),
+  county: z.string(),
+  formatted: z.string(),
+  geography: GeographicContext$inboundSchema.optional(),
+  line_1: z.string(),
+  line_2: z.string(),
+  line_3: z.string(),
+  object: SearchRetrieveResponseObject$inboundSchema,
+  post_town: z.string(),
+  postcode: z.string(),
+  search_id: z.nullable(z.string()),
+  uprn: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "classification_code": "classificationCode",
+    "line_1": "line1",
+    "line_2": "line2",
+    "line_3": "line3",
+    "post_town": "postTown",
+    "search_id": "searchId",
+  });
+});
+
+export function searchRetrieveResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchRetrieveResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchRetrieveResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchRetrieveResponse' from JSON`,
+  );
+}