@vepler/sdk 2.33.0 → 2.37.0

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

@@ -0,0 +1,58 @@
+/*
+ * 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 {
+  OfficerSummary,
+  OfficerSummary$inboundSchema,
+} from "./officersummary.js";
+import { Person, Person$inboundSchema } from "./person.js";
+import { PscSummary, PscSummary$inboundSchema } from "./pscsummary.js";
+
+/**
+ * Response containing a single deduplicated person record.
+ */
+export type PersonResponse = {
+  /**
+   * Officer appointments held by this person (if requested).
+   */
+  appointments?: Array<OfficerSummary> | undefined;
+  /**
+   * PSC notification records linked to this person (if requested).
+   */
+  pscNotifications?: Array<PscSummary> | undefined;
+  /**
+   * The full deduplicated person record.
+   */
+  result: Person;
+  /**
+   * Indicates the request was successful.
+   */
+  success: boolean;
+};
+
+/** @internal */
+export const PersonResponse$inboundSchema: z.ZodType<
+  PersonResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  appointments: z.array(OfficerSummary$inboundSchema).optional(),
+  pscNotifications: z.array(PscSummary$inboundSchema).optional(),
+  result: Person$inboundSchema,
+  success: z.boolean(),
+});
+
+export function personResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PersonResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PersonResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PersonResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,85 @@
+/*
+ * 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 { DateOfBirth, DateOfBirth$inboundSchema } from "./dateofbirth.js";
+
+/**
+ * The canonical (primary) person record in this cluster. This is the authoritative representation of the individual. Null if no canonical record has been designated.
+ */
+export type PersonSummary = {
+  /**
+   * Number of currently active (non-resigned) officer appointments.
+   */
+  activeAppointments: number;
+  /**
+   * Entity resolution cluster identifier. Requires COMPANIES_HOUSE_PREMIUM.
+   */
+  clusterId?: string | null | undefined;
+  /**
+   * Country of usual residence.
+   */
+  countryOfResidence?: string | null | undefined;
+  dateOfBirth?: DateOfBirth | null | undefined;
+  /**
+   * First (given) name.
+   */
+  forename?: string | null | undefined;
+  /**
+   * Unique identifier for this person record (UUID v4).
+   */
+  id: string;
+  /**
+   * Whether this is the canonical (primary) record within its entity resolution cluster.
+   */
+  isCanonical: boolean;
+  /**
+   * Full name as recorded, typically uppercase.
+   */
+  name: string;
+  /**
+   * Nationality as declared.
+   */
+  nationality?: string | null | undefined;
+  /**
+   * Surname (family name).
+   */
+  surname?: string | null | undefined;
+  /**
+   * Total officer appointments (active and resigned) across all companies.
+   */
+  totalAppointments: number;
+};
+
+/** @internal */
+export const PersonSummary$inboundSchema: z.ZodType<
+  PersonSummary,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  activeAppointments: z.number().int(),
+  clusterId: z.nullable(z.string()).optional(),
+  countryOfResidence: z.nullable(z.string()).optional(),
+  dateOfBirth: z.nullable(DateOfBirth$inboundSchema).optional(),
+  forename: z.nullable(z.string()).optional(),
+  id: z.string(),
+  isCanonical: z.boolean(),
+  name: z.string(),
+  nationality: z.nullable(z.string()).optional(),
+  surname: z.nullable(z.string()).optional(),
+  totalAppointments: z.number().int(),
+});
+
+export function personSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<PersonSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PersonSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PersonSummary' from JSON`,
+  );
+}

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

@@ -9,18 +9,189 @@ import { ClosedEnum, OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * GeoJSON geometry type, always 'Point' for application site centroids.
+ */
 export const PlanningApplicationType = {
   Point: "Point",
 } as const;
+/**
+ * GeoJSON geometry type, always 'Point' for application site centroids.
+ */
 export type PlanningApplicationType = ClosedEnum<
   typeof PlanningApplicationType
 >;
 
+/**
+ * Application site centroid as a GeoJSON Point geometry (RFC 7946). Coordinates are in [longitude, latitude] order using the WGS84 datum (EPSG:4326). This point represents the approximate centre of the application site, derived from the planning authority's spatial data or geocoded from the site address. Null if no spatial data was available from the source. For the full site boundary, see spatialFeatures.
+ */
 export type Spatial = {
+  /**
+   * Coordinate pair in GeoJSON [longitude, latitude] order. Uses the WGS84 coordinate reference system (EPSG:4326). Example: [-0.1278, 51.5074] represents a point in central London.
+   */
   coordinates: Array<number>;
+  /**
+   * GeoJSON geometry type, always 'Point' for application site centroids.
+   */
   type: PlanningApplicationType;
 };
 
+/**
+ * GeoJSON geometry type
+ */
+export const PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType = {
+  MultiPolygon: "MultiPolygon",
+} as const;
+/**
+ * GeoJSON geometry type
+ */
+export type PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType =
+  ClosedEnum<
+    typeof PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType
+  >;
+
+/**
+ * GeoJSON MultiPolygon geometry
+ */
+export type PlanningApplicationGeoJSONMultiPolygon = {
+  /**
+   * Array of polygon coordinate arrays
+   */
+  coordinates: Array<Array<Array<Array<number>>>>;
+  /**
+   * GeoJSON geometry type
+   */
+  type: PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType;
+};
+
+/**
+ * GeoJSON geometry type
+ */
+export const PlanningApplicationSchemasSpatialFeaturesFeaturesType = {
+  Polygon: "Polygon",
+} as const;
+/**
+ * GeoJSON geometry type
+ */
+export type PlanningApplicationSchemasSpatialFeaturesFeaturesType = ClosedEnum<
+  typeof PlanningApplicationSchemasSpatialFeaturesFeaturesType
+>;
+
+/**
+ * GeoJSON Polygon geometry
+ */
+export type PlanningApplicationGeoJSONPolygon = {
+  /**
+   * Array of linear rings
+   */
+  coordinates: Array<Array<Array<number>>>;
+  /**
+   * GeoJSON geometry type
+   */
+  type: PlanningApplicationSchemasSpatialFeaturesFeaturesType;
+};
+
+/**
+ * GeoJSON geometry type
+ */
+export const PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type = {
+  Point: "Point",
+} as const;
+/**
+ * GeoJSON geometry type
+ */
+export type PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type =
+  ClosedEnum<
+    typeof PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type
+  >;
+
+/**
+ * GeoJSON Point geometry
+ */
+export type GeoJSONPoint = {
+  /**
+   * Coordinate pair [longitude, latitude]
+   */
+  coordinates: Array<number>;
+  /**
+   * GeoJSON geometry type
+   */
+  type: PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type;
+};
+
+/**
+ * The geometry of this feature. May be a Point (site centroid), Polygon (single boundary), or MultiPolygon (disjoint site areas). Null if the geometry could not be parsed from the source data. Coordinates are in [longitude, latitude] order (WGS84, EPSG:4326).
+ */
+export type Geometry =
+  | GeoJSONPoint
+  | PlanningApplicationGeoJSONPolygon
+  | PlanningApplicationGeoJSONMultiPolygon
+  | any;
+
+/**
+ * GeoJSON feature type, always 'Feature'.
+ */
+export const PlanningApplicationSchemasSpatialFeaturesType = {
+  Feature: "Feature",
+} as const;
+/**
+ * GeoJSON feature type, always 'Feature'.
+ */
+export type PlanningApplicationSchemasSpatialFeaturesType = ClosedEnum<
+  typeof PlanningApplicationSchemasSpatialFeaturesType
+>;
+
+export type PlanningApplicationFeatures = {
+  /**
+   * The geometry of this feature. May be a Point (site centroid), Polygon (single boundary), or MultiPolygon (disjoint site areas). Null if the geometry could not be parsed from the source data. Coordinates are in [longitude, latitude] order (WGS84, EPSG:4326).
+   */
+  geometry?:
+    | GeoJSONPoint
+    | PlanningApplicationGeoJSONPolygon
+    | PlanningApplicationGeoJSONMultiPolygon
+    | any
+    | null
+    | undefined;
+  /**
+   * Key-value metadata associated with this geometry feature. Content varies by source and may include area measurements, boundary descriptions, or source attribution.
+   */
+  properties?: { [k: string]: any | null } | undefined;
+  /**
+   * GeoJSON feature type, always 'Feature'.
+   */
+  type: PlanningApplicationSchemasSpatialFeaturesType;
+};
+
+/**
+ * GeoJSON object type, always 'FeatureCollection'.
+ */
+export const PlanningApplicationSchemasType = {
+  FeatureCollection: "FeatureCollection",
+} as const;
+/**
+ * GeoJSON object type, always 'FeatureCollection'.
+ */
+export type PlanningApplicationSchemasType = ClosedEnum<
+  typeof PlanningApplicationSchemasType
+>;
+
+/**
+ * Full application site geometry as a GeoJSON FeatureCollection (RFC 7946). May contain Point, Polygon, or MultiPolygon geometries representing the application site boundary or boundaries. Coordinates are in [longitude, latitude] order using the WGS84 datum (EPSG:4326). Polygon rings follow the right-hand rule (exterior rings are counterclockwise). This field provides the detailed site boundary when available, whereas the spatial field provides only the centroid point. Null if no geometry data was available from the planning authority.
+ */
+export type SpatialFeatures = {
+  /**
+   * Array of GeoJSON Feature objects representing the application site geometry. Most applications have a single feature, but sites spanning multiple parcels may have several.
+   */
+  features: Array<PlanningApplicationFeatures>;
+  /**
+   * GeoJSON object type, always 'FeatureCollection'.
+   */
+  type: PlanningApplicationSchemasType;
+};
+
+/**
+ * Normalised status of the planning application. The typical lifecycle flows: received -> pending_validation -> valid -> under_consideration -> consultation -> pending_decision -> approved/rejected. Values: 'received' -- application submitted to the planning authority. 'pending_validation' -- awaiting initial administrative checks (fee payment, correct forms, ownership certificates). 'invalid' -- failed validation checks; the applicant must resubmit or provide missing information. 'valid' -- passed validation and registered; the application now proceeds to assessment. 'under_consideration' -- actively being assessed by planning officers, including site visits and policy review. 'consultation' -- in the statutory or public consultation period where neighbours and consultees may comment. 'pending_decision' -- officer assessment is complete; awaiting committee hearing or delegated decision. 'approved' -- planning permission has been granted (may be subject to conditions). 'rejected' -- planning permission has been refused by the authority. 'withdrawn' -- the applicant withdrew the application before a decision was made. 'appeal' -- the applicant has appealed the decision to the Planning Inspectorate. 'on_hold' -- processing has been temporarily paused by the authority (e.g. pending further information). 'expired' -- the application lapsed without a formal decision being issued. 'unknown' -- the original status text could not be mapped to a normalised value; check statusExternal for the raw text.
+ */
 export const PlanningApplicationStatus = {
   Received: "received",
   PendingValidation: "pending_validation",
@@ -37,36 +208,93 @@ export const PlanningApplicationStatus = {
   Expired: "expired",
   Unknown: "unknown",
 } as const;
+/**
+ * Normalised status of the planning application. The typical lifecycle flows: received -> pending_validation -> valid -> under_consideration -> consultation -> pending_decision -> approved/rejected. Values: 'received' -- application submitted to the planning authority. 'pending_validation' -- awaiting initial administrative checks (fee payment, correct forms, ownership certificates). 'invalid' -- failed validation checks; the applicant must resubmit or provide missing information. 'valid' -- passed validation and registered; the application now proceeds to assessment. 'under_consideration' -- actively being assessed by planning officers, including site visits and policy review. 'consultation' -- in the statutory or public consultation period where neighbours and consultees may comment. 'pending_decision' -- officer assessment is complete; awaiting committee hearing or delegated decision. 'approved' -- planning permission has been granted (may be subject to conditions). 'rejected' -- planning permission has been refused by the authority. 'withdrawn' -- the applicant withdrew the application before a decision was made. 'appeal' -- the applicant has appealed the decision to the Planning Inspectorate. 'on_hold' -- processing has been temporarily paused by the authority (e.g. pending further information). 'expired' -- the application lapsed without a formal decision being issued. 'unknown' -- the original status text could not be mapped to a normalised value; check statusExternal for the raw text.
+ */
 export type PlanningApplicationStatus = OpenEnum<
   typeof PlanningApplicationStatus
 >;
 
 export type PlanningApplication = {
+  /**
+   * The date on which an appeal was lodged with the Planning Inspectorate, formatted as an ISO 8601 datetime string. An appeal may be lodged when an application is refused or when the authority fails to determine the application within the statutory time limit. Null if no appeal has been lodged.
+   */
   appealedDate?: string | null | undefined;
+  /**
+   * The current status of an appeal, if one has been lodged. Values are not normalised and reflect the terminology used by the Planning Inspectorate or the source council (e.g. 'Appeal Lodged', 'Appeal Dismissed', 'Appeal Allowed', 'Appeal Withdrawn'). Null if no appeal has been lodged or if the status is not available.
+   */
   appealedStatus?: string | null | undefined;
+  /**
+   * ISO 8601 datetime string indicating when this record was first created in our system. This is not the date the application was submitted to the council; see receivedDate for that. Example: '2024-06-01T14:30:00.000Z'.
+   */
   createdAt: string;
+  /**
+   * Free-text description of the proposed development as provided by the applicant or planning authority. Typically summarises the works being proposed (e.g. 'Erection of a two-storey rear extension and loft conversion with rear dormer'). The level of detail varies by council. Null if no description was available from the source data.
+   */
   description?: string | null | undefined;
+  /**
+   * High-level classification of the proposed development, derived from the application description and type using AI. Common values include: 'Residential' (new homes, conversions to dwellings), 'Commercial' (offices, retail, hospitality), 'Industrial' (manufacturing, warehousing), 'Mixed Use' (combination of residential and commercial), 'Infrastructure' (roads, utilities, telecommunications), 'Change of Use' (altering the permitted use class of a building). Null if the development could not be classified. This field is useful for filtering applications by broad development sector.
+   */
   developmentCategory?: string | null | undefined;
+  /**
+   * Unique identifier for the planning application record. Use this UUID to retrieve the application via the GET /{applicationIds} endpoint.
+   */
   id: string;
   /**
-   * Application reference number
+   * The planning application reference number as assigned by the local planning authority. Format varies by council (e.g. 'APP/2024/0001', '24/00123/FUL', 'DC/24/0456'). This is the reference number a member of the public would use when contacting the council about the application.
    */
   key: string;
   /**
-   * Council or planning authority
+   * Identifier for the local planning authority (LPA) or council that received the application. This is a normalised slug derived from the council name (e.g. 'lambeth', 'manchester', 'st-albans'). Use this value in the query endpoint's councils filter to retrieve all applications from a specific authority.
    */
   provider: string;
+  /**
+   * The date on which the planning authority received the application, formatted as an ISO 8601 datetime string (e.g. '2024-03-15T00:00:00.000Z'). This is the official submission date and is typically the earliest date in the application timeline. Null if the date was not recorded by the source. Use receivedDateFrom/receivedDateTo in the query endpoint to filter by this date.
+   */
   receivedDate?: string | null | undefined;
+  /**
+   * Composite identifier combining provider and key in the format 'provider::key' (e.g. 'lambeth::24/00123/FUL'). This provides a globally unique, human-readable identifier for the application. Use this value with the GET /sources/{sourceIds} endpoint to look up applications by their council reference.
+   */
   sourceId: string;
+  /**
+   * Application site centroid as a GeoJSON Point geometry (RFC 7946). Coordinates are in [longitude, latitude] order using the WGS84 datum (EPSG:4326). This point represents the approximate centre of the application site, derived from the planning authority's spatial data or geocoded from the site address. Null if no spatial data was available from the source. For the full site boundary, see spatialFeatures.
+   */
   spatial?: Spatial | null | undefined;
-  spatialFeatures?: any | null | undefined;
+  /**
+   * Full application site geometry as a GeoJSON FeatureCollection (RFC 7946). May contain Point, Polygon, or MultiPolygon geometries representing the application site boundary or boundaries. Coordinates are in [longitude, latitude] order using the WGS84 datum (EPSG:4326). Polygon rings follow the right-hand rule (exterior rings are counterclockwise). This field provides the detailed site boundary when available, whereas the spatial field provides only the centroid point. Null if no geometry data was available from the planning authority.
+   */
+  spatialFeatures?: SpatialFeatures | null | undefined;
+  /**
+   * Normalised status of the planning application. The typical lifecycle flows: received -> pending_validation -> valid -> under_consideration -> consultation -> pending_decision -> approved/rejected. Values: 'received' -- application submitted to the planning authority. 'pending_validation' -- awaiting initial administrative checks (fee payment, correct forms, ownership certificates). 'invalid' -- failed validation checks; the applicant must resubmit or provide missing information. 'valid' -- passed validation and registered; the application now proceeds to assessment. 'under_consideration' -- actively being assessed by planning officers, including site visits and policy review. 'consultation' -- in the statutory or public consultation period where neighbours and consultees may comment. 'pending_decision' -- officer assessment is complete; awaiting committee hearing or delegated decision. 'approved' -- planning permission has been granted (may be subject to conditions). 'rejected' -- planning permission has been refused by the authority. 'withdrawn' -- the applicant withdrew the application before a decision was made. 'appeal' -- the applicant has appealed the decision to the Planning Inspectorate. 'on_hold' -- processing has been temporarily paused by the authority (e.g. pending further information). 'expired' -- the application lapsed without a formal decision being issued. 'unknown' -- the original status text could not be mapped to a normalised value; check statusExternal for the raw text.
+   */
   status: PlanningApplicationStatus;
+  /**
+   * Confidence score for the AI-driven status normalisation, expressed as a decimal between 0 and 1. A score above 0.9 indicates high confidence that the normalised status accurately reflects the original text. A score between 0.7 and 0.9 suggests reasonable confidence but some ambiguity. A score below 0.7 indicates the original text was unclear or unusual -- in this case, check statusExternal for the raw value and treat the normalised status with caution. Null if no normalisation was performed.
+   */
   statusConfidence?: number | null | undefined;
+  /**
+   * The original, unmodified status text as published by the planning authority. Each council uses its own terminology (e.g. 'Permitted Development', 'Application Registered', 'Awaiting Decision'). This field preserves the raw value before normalisation. Useful for debugging when the normalised status is 'unknown' or when you need the exact wording used by the council.
+   */
   statusExternal?: string | null | undefined;
+  /**
+   * Normalised planning application type describing the category of development or consent being sought. Common values include: 'Full Planning' (full planning permission for new development), 'Householder' (extensions or alterations to a dwelling), 'Listed Building Consent' (works affecting a listed building), 'Prior Approval' (permitted development requiring prior approval from the authority), 'Outline Planning' (establishes the principle of development before detailed plans), 'Reserved Matters' (detailed plans following outline approval), 'Discharge of Conditions' (removing conditions attached to a previous permission), 'Tree Works' (works to protected trees or trees in conservation areas), 'Advertisement Consent' (displaying advertisements), 'Certificate of Lawfulness' (confirming existing or proposed use is lawful). Null if the type could not be determined from the source data. See typeExternal for the original text from the planning authority.
+   */
   type?: string | null | undefined;
+  /**
+   * Confidence score for the AI-driven type normalisation, expressed as a decimal between 0 and 1. A score above 0.9 indicates high confidence that the normalised type accurately reflects the original text. A score below 0.7 suggests the original text was ambiguous or unusual -- check typeExternal for the raw value. Null if no normalisation was performed.
+   */
   typeConfidence?: number | null | undefined;
+  /**
+   * The original, unmodified application type text as published by the planning authority. Councils use varied terminology for the same application types (e.g. 'Full Application', 'Full Planning Permission', 'FUL' may all map to the normalised type 'Full Planning'). This field preserves the raw classification. Useful when the normalised type is null or when you need the exact wording used by the council.
+   */
   typeExternal?: string | null | undefined;
+  /**
+   * ISO 8601 datetime string indicating when this record was last updated in our system. Changes occur when the planning authority publishes new information (status changes, new documents, amended descriptions). Example: '2024-08-15T09:00:00.000Z'.
+   */
   updatedAt: string;
+  /**
+   * The date on which the application was formally validated by the planning authority, formatted as an ISO 8601 datetime string (e.g. '2024-03-20T00:00:00.000Z'). Validation confirms that the application is complete (correct forms, fees paid, certificates provided) and can proceed to assessment. The statutory determination period typically begins from this date. Null if the date was not recorded by the source.
+   */
   validatedDate?: string | null | undefined;
 };
 
@@ -92,6 +320,171 @@ export function spatialFromJSON(
   );
 }
 
+/** @internal */
+export const PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType
+  > = z.nativeEnum(
+    PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType,
+  );
+
+/** @internal */
+export const PlanningApplicationGeoJSONMultiPolygon$inboundSchema: z.ZodType<
+  PlanningApplicationGeoJSONMultiPolygon,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinates: z.array(z.array(z.array(z.array(z.number())))),
+  type:
+    PlanningApplicationSchemasSpatialFeaturesFeaturesGeometryType$inboundSchema,
+});
+
+export function planningApplicationGeoJSONMultiPolygonFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningApplicationGeoJSONMultiPolygon, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PlanningApplicationGeoJSONMultiPolygon$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningApplicationGeoJSONMultiPolygon' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlanningApplicationSchemasSpatialFeaturesFeaturesType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof PlanningApplicationSchemasSpatialFeaturesFeaturesType
+  > = z.nativeEnum(PlanningApplicationSchemasSpatialFeaturesFeaturesType);
+
+/** @internal */
+export const PlanningApplicationGeoJSONPolygon$inboundSchema: z.ZodType<
+  PlanningApplicationGeoJSONPolygon,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinates: z.array(z.array(z.array(z.number()))),
+  type: PlanningApplicationSchemasSpatialFeaturesFeaturesType$inboundSchema,
+});
+
+export function planningApplicationGeoJSONPolygonFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningApplicationGeoJSONPolygon, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningApplicationGeoJSONPolygon$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningApplicationGeoJSONPolygon' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type$inboundSchema:
+  z.ZodNativeEnum<
+    typeof PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type
+  > = z.nativeEnum(
+    PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type,
+  );
+
+/** @internal */
+export const GeoJSONPoint$inboundSchema: z.ZodType<
+  GeoJSONPoint,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinates: z.array(z.number()),
+  type:
+    PlanningApplicationSchemasSpatialFeaturesFeaturesGeometry1Type$inboundSchema,
+});
+
+export function geoJSONPointFromJSON(
+  jsonString: string,
+): SafeParseResult<GeoJSONPoint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GeoJSONPoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GeoJSONPoint' from JSON`,
+  );
+}
+
+/** @internal */
+export const Geometry$inboundSchema: z.ZodType<
+  Geometry,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => GeoJSONPoint$inboundSchema),
+  z.lazy(() => PlanningApplicationGeoJSONPolygon$inboundSchema),
+  z.lazy(() => PlanningApplicationGeoJSONMultiPolygon$inboundSchema),
+  z.any(),
+]);
+
+export function geometryFromJSON(
+  jsonString: string,
+): SafeParseResult<Geometry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Geometry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Geometry' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlanningApplicationSchemasSpatialFeaturesType$inboundSchema:
+  z.ZodNativeEnum<typeof PlanningApplicationSchemasSpatialFeaturesType> = z
+    .nativeEnum(PlanningApplicationSchemasSpatialFeaturesType);
+
+/** @internal */
+export const PlanningApplicationFeatures$inboundSchema: z.ZodType<
+  PlanningApplicationFeatures,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  geometry: z.nullable(
+    z.union([
+      z.lazy(() => GeoJSONPoint$inboundSchema),
+      z.lazy(() => PlanningApplicationGeoJSONPolygon$inboundSchema),
+      z.lazy(() => PlanningApplicationGeoJSONMultiPolygon$inboundSchema),
+      z.any(),
+    ]),
+  ).optional(),
+  properties: z.record(z.nullable(z.any())).optional(),
+  type: PlanningApplicationSchemasSpatialFeaturesType$inboundSchema,
+});
+
+export function planningApplicationFeaturesFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningApplicationFeatures, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningApplicationFeatures$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningApplicationFeatures' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlanningApplicationSchemasType$inboundSchema: z.ZodNativeEnum<
+  typeof PlanningApplicationSchemasType
+> = z.nativeEnum(PlanningApplicationSchemasType);
+
+/** @internal */
+export const SpatialFeatures$inboundSchema: z.ZodType<
+  SpatialFeatures,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  features: z.array(z.lazy(() => PlanningApplicationFeatures$inboundSchema)),
+  type: PlanningApplicationSchemasType$inboundSchema,
+});
+
+export function spatialFeaturesFromJSON(
+  jsonString: string,
+): SafeParseResult<SpatialFeatures, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SpatialFeatures$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SpatialFeatures' from JSON`,
+  );
+}
+
 /** @internal */
 export const PlanningApplicationStatus$inboundSchema: z.ZodType<
   PlanningApplicationStatus,
@@ -116,7 +509,8 @@ export const PlanningApplication$inboundSchema: z.ZodType<
   receivedDate: z.nullable(z.string()).optional(),
   sourceId: z.string(),
   spatial: z.nullable(z.lazy(() => Spatial$inboundSchema)).optional(),
-  spatialFeatures: z.nullable(z.any()).optional(),
+  spatialFeatures: z.nullable(z.lazy(() => SpatialFeatures$inboundSchema))
+    .optional(),
   status: PlanningApplicationStatus$inboundSchema,
   statusConfidence: z.nullable(z.number()).optional(),
   statusExternal: z.nullable(z.string()).optional(),