@vepler/sdk 2.167.0 → 3.3.0

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

@@ -23,6 +23,17 @@ import {
 } from "./sitepropertystats.js";
 import { SiteTags, SiteTags$inboundSchema } from "./sitetags.js";
 
+/**
+ * GeoJSON geometry type
+ */
+export const SiteSchemasType = {
+  MultiPolygon: "MultiPolygon",
+} as const;
+/**
+ * GeoJSON geometry type
+ */
+export type SiteSchemasType = ClosedEnum<typeof SiteSchemasType>;
+
 /**
  * GeoJSON MultiPolygon geometry
  */
@@ -30,13 +41,24 @@ export type SiteGeoJSONMultiPolygon = {
   /**
    * Array of polygon coordinate arrays
    */
-  coordinates: Array<Array<Array<Array<number>>>>;
+  coordinates?: Array<Array<Array<Array<number>>>> | undefined;
   /**
    * GeoJSON geometry type
    */
-  type: "MultiPolygon";
+  type?: SiteSchemasType | undefined;
 };
 
+/**
+ * GeoJSON geometry type
+ */
+export const SiteType = {
+  Polygon: "Polygon",
+} as const;
+/**
+ * GeoJSON geometry type
+ */
+export type SiteType = ClosedEnum<typeof SiteType>;
+
 /**
  * GeoJSON Polygon geometry
  */
@@ -44,11 +66,11 @@ export type SiteGeoJSONPolygon = {
   /**
    * Array of linear rings
    */
-  coordinates: Array<Array<Array<number>>>;
+  coordinates?: Array<Array<Array<number>>> | undefined;
   /**
    * GeoJSON geometry type
    */
-  type: "Polygon";
+  type?: SiteType | undefined;
 };
 
 /**
@@ -63,11 +85,11 @@ export type SiteCoordinates = {
   /**
    * Latitude in decimal degrees
    */
-  lat: number;
+  lat?: number | undefined;
   /**
    * Longitude in decimal degrees
    */
-  lng: number;
+  lng?: number | undefined;
 };
 
 /**
@@ -172,11 +194,11 @@ export type Site = {
   /**
    * Area-level metrics from the LSOA (Lower Layer Super Output Area) containing the site centroid. Includes crime, deprivation, connectivity, and prosperity indices. Null when the centroid cannot be matched to an LSOA (e.g. sites outside England and Wales).
    */
-  areaMetrics: SiteAreaMetrics | null;
+  areaMetrics?: SiteAreaMetrics | null | undefined;
   /**
    * Site area in square metres, calculated from the boundary polygon
    */
-  areaSqm: number;
+  areaSqm?: number | undefined;
   /**
    * Site boundary geometry in WGS84 (EPSG:4326). GeoJSON Polygon or MultiPolygon with coordinates in [longitude, latitude] order. Excluded from the default attribute set for performance — request explicitly via `attributes: ["boundary"]`.
    */
@@ -192,7 +214,7 @@ export type Site = {
   /**
    * ISO 3166-1 alpha-2 country code
    */
-  country: string;
+  country?: string | undefined;
   /**
    * HM Land Registry estate interest code. Almost always "EL" (Estate in Land). Does not indicate freehold/leasehold — use `classTitleCode` or `tenureType` instead. Not included in the default attribute set — request explicitly via `attributes: ["estateInterestCode"]`.
    */
@@ -200,11 +222,11 @@ export type Site = {
   /**
    * Land use classifications derived from spatial analysis of overlay data and OS NGD Land.
    */
-  landUse: Array<LandUse>;
+  landUse?: Array<LandUse> | undefined;
   /**
    * Number of UPRNs linked to this title
    */
-  locationCount: number;
+  locationCount?: number | undefined;
   /**
    * UPRNs (Unique Property Reference Numbers) linked to this title via spatial intersection with the Ordnance Survey AddressBase dataset. Not included in the default attribute set — request explicitly via `attributes: ["locationIds"]`.
    */
@@ -212,19 +234,19 @@ export type Site = {
   /**
    * Object type identifier
    */
-  object: SiteObject;
+  object?: SiteObject | undefined;
   /**
    * Spatial overlay keywords derived from area reference data intersecting the site boundary. Examples include flood risk zones, conservation areas, green belt, listed building curtilage, and other planning designations. Values are not from a fixed enum — they depend on available area reference datasets.
    */
-  overlays: Array<string>;
+  overlays?: Array<string> | undefined;
   /**
    * Title ownership data from CCOD/OCOD/title deeds
    */
-  ownership: SiteOwnership | null;
+  ownership?: SiteOwnership | null | undefined;
   /**
    * Planning application statistics from applications whose boundary intersects this site. Null when no planning applications intersect or when enrichment has not yet run.
    */
-  planning: SitePlanningStats | null;
+  planning?: SitePlanningStats | null | undefined;
   /**
    * Internal polygon identifiers from the source shapefile. Used for provenance tracking; not typically needed by API consumers. Not included in the default attribute set — request explicitly via `attributes: ["polygonIds"]`.
    */
@@ -232,31 +254,31 @@ export type Site = {
   /**
    * Aggregated statistics for properties linked to this site. Null when no properties are linked (locationCount is 0) or when enrichment has not yet run.
    */
-  propertyStats: SitePropertyStats | null;
+  propertyStats?: SitePropertyStats | null | undefined;
   /**
    * UTC date the title was first registered with HM Land Registry, in ISO 8601 format
    */
-  registeredAt: string | null;
+  registeredAt?: string | null | undefined;
   /**
    * Land registry identifier
    */
-  registry: string;
+  registry?: string | undefined;
   /**
    * Identifiers of geographic entities that spatially intersect or contain this site. Includes local authority codes, ward codes, parish codes, and other administrative area references.
    */
-  relationships: Array<string>;
+  relationships?: Array<string> | undefined;
   /**
    * Composite site identifier: {country}:{registry}:{titleRef}
    */
-  siteId: string;
+  siteId?: string | undefined;
   /**
    * Data sources for this site
    */
-  sources: Array<string>;
+  sources?: Array<string> | undefined;
   /**
    * Site record status. "active" — current registered title. "pending" — title awaiting registration or enrichment. "closed" — title no longer active (merged, cancelled, or superseded).
    */
-  status: SiteStatus;
+  status?: SiteStatus | undefined;
   /**
    * Boolean tags derived automatically during enrichment. Useful for quick filtering without complex queries.
    */
@@ -264,25 +286,30 @@ export type Site = {
   /**
    * Derived tenure type based on classTitleCode. Null when classTitleCode is unavailable.
    */
-  tenureType: TenureType | null;
+  tenureType?: TenureType | null | undefined;
   /**
    * Title number from the land registry
    */
-  titleRef: string;
+  titleRef?: string | undefined;
   /**
    * UTC datetime when the site record was last enriched or updated, in ISO 8601 format
    */
-  updatedAt: string | null;
+  updatedAt?: string | null | undefined;
 };
 
+/** @internal */
+export const SiteSchemasType$inboundSchema: z.ZodNativeEnum<
+  typeof SiteSchemasType
+> = z.nativeEnum(SiteSchemasType);
+
 /** @internal */
 export const SiteGeoJSONMultiPolygon$inboundSchema: z.ZodType<
   SiteGeoJSONMultiPolygon,
   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: SiteSchemasType$inboundSchema.optional(),
 });
 
 export function siteGeoJSONMultiPolygonFromJSON(
@@ -295,14 +322,18 @@ export function siteGeoJSONMultiPolygonFromJSON(
   );
 }
 
+/** @internal */
+export const SiteType$inboundSchema: z.ZodNativeEnum<typeof SiteType> = z
+  .nativeEnum(SiteType);
+
 /** @internal */
 export const SiteGeoJSONPolygon$inboundSchema: z.ZodType<
   SiteGeoJSONPolygon,
   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: SiteType$inboundSchema.optional(),
 });
 
 export function siteGeoJSONPolygonFromJSON(
@@ -341,8 +372,8 @@ export const SiteCoordinates$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  lat: z.number(),
-  lng: z.number(),
+  lat: z.number().optional(),
+  lng: z.number().optional(),
 });
 
 export function siteCoordinatesFromJSON(
@@ -394,35 +425,35 @@ export const TenureType$inboundSchema: z.ZodType<
 /** @internal */
 export const Site$inboundSchema: z.ZodType<Site, z.ZodTypeDef, unknown> = z
   .object({
-    areaMetrics: z.nullable(SiteAreaMetrics$inboundSchema),
-    areaSqm: z.number(),
+    areaMetrics: z.nullable(SiteAreaMetrics$inboundSchema).optional(),
+    areaSqm: z.number().optional(),
     boundary: z.union([
       z.lazy(() => SiteGeoJSONPolygon$inboundSchema),
       z.lazy(() => SiteGeoJSONMultiPolygon$inboundSchema),
     ]).optional(),
     centroid: z.lazy(() => SiteCoordinates$inboundSchema).optional(),
     classTitleCode: z.nullable(ClassTitleCode$inboundSchema).optional(),
-    country: z.string(),
+    country: z.string().optional(),
     estateInterestCode: z.nullable(EstateInterestCode$inboundSchema).optional(),
-    landUse: z.array(LandUse$inboundSchema),
-    locationCount: z.number(),
+    landUse: z.array(LandUse$inboundSchema).optional(),
+    locationCount: z.number().optional(),
     locationIds: z.array(z.string()).optional(),
-    object: SiteObject$inboundSchema,
-    overlays: z.array(z.string()),
-    ownership: z.nullable(SiteOwnership$inboundSchema),
-    planning: z.nullable(SitePlanningStats$inboundSchema),
+    object: SiteObject$inboundSchema.optional(),
+    overlays: z.array(z.string()).optional(),
+    ownership: z.nullable(SiteOwnership$inboundSchema).optional(),
+    planning: z.nullable(SitePlanningStats$inboundSchema).optional(),
     polygonIds: z.array(z.number()).optional(),
-    propertyStats: z.nullable(SitePropertyStats$inboundSchema),
-    registeredAt: z.nullable(z.string()),
-    registry: z.string(),
-    relationships: z.array(z.string()),
-    siteId: z.string(),
-    sources: z.array(z.string()),
-    status: SiteStatus$inboundSchema,
+    propertyStats: z.nullable(SitePropertyStats$inboundSchema).optional(),
+    registeredAt: z.nullable(z.string()).optional(),
+    registry: z.string().optional(),
+    relationships: z.array(z.string()).optional(),
+    siteId: z.string().optional(),
+    sources: z.array(z.string()).optional(),
+    status: SiteStatus$inboundSchema.optional(),
     tags: SiteTags$inboundSchema.optional(),
-    tenureType: z.nullable(TenureType$inboundSchema),
-    titleRef: z.string(),
-    updatedAt: z.nullable(z.string()),
+    tenureType: z.nullable(TenureType$inboundSchema).optional(),
+    titleRef: z.string().optional(),
+    updatedAt: z.nullable(z.string()).optional(),
   });
 
 export function siteFromJSON(

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

@@ -49,31 +49,31 @@ export type SiteOwnership = {
   /**
    * Company registration number of the primary proprietor
    */
-  companyNumber: string | null;
+  companyNumber?: string | null | undefined;
   /**
    * Date the primary proprietor was added
    */
-  dateProprietorAdded: string | null;
+  dateProprietorAdded?: string | null | undefined;
   /**
    * Whether the title has multiple proprietors
    */
-  isJointOwnership: boolean;
+  isJointOwnership?: boolean | undefined;
   /**
    * Primary ownership category
    */
-  ownershipCategory: OwnershipCategory;
+  ownershipCategory?: OwnershipCategory | undefined;
   /**
    * Display name of the primary proprietor
    */
-  primaryOwnerName: string;
+  primaryOwnerName?: string | undefined;
   /**
    * All current proprietors of this title
    */
-  proprietors: Array<SiteProprietor>;
+  proprietors?: Array<SiteProprietor> | undefined;
   /**
    * Data source for ownership information
    */
-  source: SiteOwnershipSource;
+  source?: SiteOwnershipSource | undefined;
 };
 
 /** @internal */
@@ -96,13 +96,13 @@ export const SiteOwnership$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  companyNumber: z.nullable(z.string()),
-  dateProprietorAdded: z.nullable(z.string()),
-  isJointOwnership: z.boolean(),
-  ownershipCategory: OwnershipCategory$inboundSchema,
-  primaryOwnerName: z.string(),
-  proprietors: z.array(SiteProprietor$inboundSchema),
-  source: SiteOwnershipSource$inboundSchema,
+  companyNumber: z.nullable(z.string()).optional(),
+  dateProprietorAdded: z.nullable(z.string()).optional(),
+  isJointOwnership: z.boolean().optional(),
+  ownershipCategory: OwnershipCategory$inboundSchema.optional(),
+  primaryOwnerName: z.string().optional(),
+  proprietors: z.array(SiteProprietor$inboundSchema).optional(),
+  source: SiteOwnershipSource$inboundSchema.optional(),
 });
 
 export function siteOwnershipFromJSON(

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

@@ -14,11 +14,11 @@ export type SitePlanningStats = {
   /**
    * Distinct application types
    */
-  applicationTypes: Array<string>;
+  applicationTypes?: Array<string> | undefined;
   /**
    * Number of approved applications
    */
-  approvals: number;
+  approvals?: number | undefined;
   /**
    * UTC date of the most recent planning application, in ISO 8601 format
    */
@@ -30,15 +30,15 @@ export type SitePlanningStats = {
   /**
    * Number of pending applications
    */
-  pending: number;
+  pending?: number | undefined;
   /**
    * Number of refused applications
    */
-  refusals: number;
+  refusals?: number | undefined;
   /**
    * Total planning applications intersecting this site
    */
-  totalApplications: number;
+  totalApplications?: number | undefined;
 };
 
 /** @internal */
@@ -47,13 +47,13 @@ export const SitePlanningStats$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  applicationTypes: z.array(z.string()),
-  approvals: z.number(),
+  applicationTypes: z.array(z.string()).optional(),
+  approvals: z.number().optional(),
   latestApplicationDate: z.string().optional(),
   latestDecision: z.string().optional(),
-  pending: z.number(),
-  refusals: z.number(),
-  totalApplications: z.number(),
+  pending: z.number().optional(),
+  refusals: z.number().optional(),
+  totalApplications: z.number().optional(),
 });
 
 export function sitePlanningStatsFromJSON(

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

@@ -22,7 +22,7 @@ export type SitePropertyStats = {
   /**
    * Distinct property types found
    */
-  propertyTypes: Array<string>;
+  propertyTypes?: Array<string> | undefined;
   /**
    * Combined floor area in square metres
    */
@@ -30,7 +30,7 @@ export type SitePropertyStats = {
   /**
    * Count of properties linked to this site
    */
-  totalProperties: number;
+  totalProperties?: number | undefined;
   /**
    * Proportion of vacant properties (0-1)
    */
@@ -45,9 +45,9 @@ export const SitePropertyStats$inboundSchema: z.ZodType<
 > = z.object({
   avgRent: z.number().optional(),
   avgValue: z.number().optional(),
-  propertyTypes: z.array(z.string()),
+  propertyTypes: z.array(z.string()).optional(),
   totalFloorArea: z.number().optional(),
-  totalProperties: z.number(),
+  totalProperties: z.number().optional(),
   vacancyRate: z.number().optional(),
 });
 

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

@@ -11,27 +11,27 @@ export type SiteProprietor = {
   /**
    * Primary address of the proprietor
    */
-  address: string | null;
+  address?: string | null | undefined;
   /**
    * Company registration number
    */
-  companyNumber: string | null;
+  companyNumber?: string | null | undefined;
   /**
    * Country of incorporation for overseas companies
    */
-  countryIncorporated: string | null;
+  countryIncorporated?: string | null | undefined;
   /**
    * Date the proprietor was added to the title
    */
-  dateAdded: string | null;
+  dateAdded?: string | null | undefined;
   /**
    * Entity type classification
    */
-  entityType: string;
+  entityType?: string | undefined;
   /**
    * Proprietor name as recorded
    */
-  name: string;
+  name?: string | undefined;
 };
 
 /** @internal */
@@ -40,12 +40,12 @@ export const SiteProprietor$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  address: z.nullable(z.string()),
-  companyNumber: z.nullable(z.string()),
-  countryIncorporated: z.nullable(z.string()),
-  dateAdded: z.nullable(z.string()),
-  entityType: z.string(),
-  name: z.string(),
+  address: z.nullable(z.string()).optional(),
+  companyNumber: z.nullable(z.string()).optional(),
+  countryIncorporated: z.nullable(z.string()).optional(),
+  dateAdded: z.nullable(z.string()).optional(),
+  entityType: z.string().optional(),
+  name: z.string().optional(),
 });
 
 export function siteProprietorFromJSON(

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

@@ -0,0 +1,181 @@
+/*
+ * 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 {
+  GeocodePrecision,
+  GeocodePrecision$inboundSchema,
+} from "./geocodeprecision.js";
+
+/**
+ * Street extent
+ */
+export type BoundingBox = {
+  /**
+   * Eastern boundary (max longitude)
+   */
+  east: number;
+  /**
+   * Northern boundary (max latitude)
+   */
+  north: number;
+  /**
+   * Southern boundary (min latitude)
+   */
+  south: number;
+  /**
+   * Western boundary (min longitude)
+   */
+  west: number;
+};
+
+/**
+ * Representative point for the street (centre)
+ */
+export type StreetMatchCoordinates = {
+  /**
+   * Latitude in decimal degrees
+   */
+  lat: number;
+  /**
+   * Longitude in decimal degrees
+   */
+  lng: number;
+};
+
+/**
+ * A named-street geocoding result, keyed on USRN
+ */
+export type StreetMatch = {
+  /**
+   * Administrative area
+   */
+  administrativeArea?: string | undefined;
+  /**
+   * Street extent
+   */
+  boundingBox?: BoundingBox | undefined;
+  /**
+   * Match confidence (0-100)
+   */
+  confidence: number;
+  /**
+   * ISO 3166-1 alpha-2 country code of the street
+   */
+  country: string;
+  /**
+   * Distance from the query point in metres, when a point was supplied
+   */
+  distance?: number | undefined;
+  /**
+   * Result granularity discriminator
+   */
+  granularity: "street";
+  /**
+   * Stable, provider-namespaced street identity in the form `<country>-<scheme>:<value>`, unique across countries. Key street results on this rather than on a national id (which differs per country — USRN in Great Britain, other schemes elsewhere).
+   */
+  id: string;
+  /**
+   * Locality within the town
+   */
+  locality?: string | undefined;
+  /**
+   * Representative point for the street (centre)
+   */
+  location: StreetMatchCoordinates;
+  /**
+   * Street name
+   */
+  name: string;
+  precision: GeocodePrecision;
+  /**
+   * Number of addressable properties on the street
+   */
+  propertyCount?: number | undefined;
+  /**
+   * Town / post town
+   */
+  town?: string | undefined;
+  /**
+   * Unique Street Reference Number — the statutory Great Britain street id (GB results only)
+   */
+  usrn?: number | undefined;
+};
+
+/** @internal */
+export const BoundingBox$inboundSchema: z.ZodType<
+  BoundingBox,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  east: z.number(),
+  north: z.number(),
+  south: z.number(),
+  west: z.number(),
+});
+
+export function boundingBoxFromJSON(
+  jsonString: string,
+): SafeParseResult<BoundingBox, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BoundingBox$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BoundingBox' from JSON`,
+  );
+}
+
+/** @internal */
+export const StreetMatchCoordinates$inboundSchema: z.ZodType<
+  StreetMatchCoordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lng: z.number(),
+});
+
+export function streetMatchCoordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<StreetMatchCoordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StreetMatchCoordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StreetMatchCoordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const StreetMatch$inboundSchema: z.ZodType<
+  StreetMatch,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  administrativeArea: z.string().optional(),
+  boundingBox: z.lazy(() => BoundingBox$inboundSchema).optional(),
+  confidence: z.number(),
+  country: z.string(),
+  distance: z.number().optional(),
+  granularity: z.literal("street"),
+  id: z.string(),
+  locality: z.string().optional(),
+  location: z.lazy(() => StreetMatchCoordinates$inboundSchema),
+  name: z.string(),
+  precision: GeocodePrecision$inboundSchema,
+  propertyCount: z.number().optional(),
+  town: z.string().optional(),
+  usrn: z.number().optional(),
+});
+
+export function streetMatchFromJSON(
+  jsonString: string,
+): SafeParseResult<StreetMatch, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StreetMatch$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StreetMatch' from JSON`,
+  );
+}