@vepler/sdk 2.42.0 → 2.46.0

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

@@ -8,6 +8,30 @@ import * as openEnums from "../../types/enums.js";
 import { ClosedEnum, OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  PlanningAddress,
+  PlanningAddress$inboundSchema,
+} from "./planningaddress.js";
+import {
+  PlanningConstraint,
+  PlanningConstraint$inboundSchema,
+} from "./planningconstraint.js";
+import {
+  PlanningDocument,
+  PlanningDocument$inboundSchema,
+} from "./planningdocument.js";
+import {
+  PlanningPeople,
+  PlanningPeople$inboundSchema,
+} from "./planningpeople.js";
+import {
+  PlanningRelatedCase,
+  PlanningRelatedCase$inboundSchema,
+} from "./planningrelatedcase.js";
+import {
+  PlanningStatusHistory,
+  PlanningStatusHistory$inboundSchema,
+} from "./planningstatushistory.js";
 
 /**
  * GeoJSON geometry type, always 'Point' for application site centroids.
@@ -216,6 +240,10 @@ export type PlanningApplicationStatus = OpenEnum<
 >;
 
 export type PlanningApplication = {
+  /**
+   * Structured address of the application site, as scraped from the planning authority. Field availability varies by council — some provide full structured addresses whilst others provide only a raw string. Null if no address data was available.
+   */
+  address?: PlanningAddress | null | undefined;
   /**
    * 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.
    */
@@ -224,10 +252,30 @@ export type PlanningApplication = {
    * 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;
+  /**
+   * Name of the planning officer assigned to assess the application. Null if the case officer was not recorded by the source council.
+   */
+  caseOfficer?: string | null | undefined;
+  /**
+   * Planning constraints affecting the application site, such as conservation areas, listed buildings, tree preservation orders, or green belt designations. Null if no constraint data was available from the source.
+   */
+  constraints?: Array<PlanningConstraint> | null | undefined;
+  /**
+   * The date on which the public consultation period closed, formatted as an ISO 8601 datetime string. Comments received after this date may not be considered. Null if the date was not recorded.
+   */
+  consultationEndDate?: string | null | undefined;
+  /**
+   * The date on which the public consultation period opened, formatted as an ISO 8601 datetime string. During this period, neighbours and statutory consultees may submit comments on the application. Null if the date was not recorded.
+   */
+  consultationStartDate?: 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;
+  /**
+   * The date on which the planning authority issued its formal decision (approval or refusal), formatted as an ISO 8601 datetime string. Null if the application has not yet been decided or the date was not recorded.
+   */
+  decidedDate?: string | null | undefined;
   /**
    * 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.
    */
@@ -236,6 +284,14 @@ export type PlanningApplication = {
    * 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;
+  /**
+   * Documents associated with the planning application, including submitted plans, decision notices, consultation responses, and supporting material. May be empty if no documents have been collected from the source.
+   */
+  documents?: Array<PlanningDocument> | undefined;
+  /**
+   * The date on which the planning permission expires if not implemented, formatted as an ISO 8601 datetime string. Most permissions must be commenced within three years of approval. Null if not applicable or not recorded.
+   */
+  expiryDate?: string | null | undefined;
   /**
    * Unique identifier for the planning application record. Use this UUID to retrieve the application via the GET /{applicationIds} endpoint.
    */
@@ -244,6 +300,10 @@ export type PlanningApplication = {
    * 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;
+  /**
+   * People associated with the application including applicants and planning agents. Contact details (phone, email) are redacted; only names and organisations are included. Null if no applicant or agent data was available.
+   */
+  people?: PlanningPeople | null | undefined;
   /**
    * 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.
    */
@@ -252,6 +312,10 @@ export type PlanningApplication = {
    * 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;
+  /**
+   * Other planning applications related to this one, such as appeals, amendments, or linked applications at the same site. Null if no related cases were recorded.
+   */
+  relatedCases?: Array<PlanningRelatedCase> | 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.
    */
@@ -276,6 +340,10 @@ export type PlanningApplication = {
    * 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;
+  /**
+   * Chronological history of status changes for the planning application. Provides an audit trail showing how the application progressed through the planning process. Entries are ordered by changedAt date, newest first. May be empty if status history tracking is not available for the source council.
+   */
+  statusHistory?: Array<PlanningStatusHistory> | 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.
    */
@@ -498,15 +566,26 @@ export const PlanningApplication$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  address: z.nullable(PlanningAddress$inboundSchema).optional(),
   appealedDate: z.nullable(z.string()).optional(),
   appealedStatus: z.nullable(z.string()).optional(),
+  caseOfficer: z.nullable(z.string()).optional(),
+  constraints: z.nullable(z.array(PlanningConstraint$inboundSchema)).optional(),
+  consultationEndDate: z.nullable(z.string()).optional(),
+  consultationStartDate: z.nullable(z.string()).optional(),
   createdAt: z.string(),
+  decidedDate: z.nullable(z.string()).optional(),
   description: z.nullable(z.string()).optional(),
   developmentCategory: z.nullable(z.string()).optional(),
+  documents: z.array(PlanningDocument$inboundSchema).optional(),
+  expiryDate: z.nullable(z.string()).optional(),
   id: z.string(),
   key: z.string(),
+  people: z.nullable(PlanningPeople$inboundSchema).optional(),
   provider: z.string(),
   receivedDate: z.nullable(z.string()).optional(),
+  relatedCases: z.nullable(z.array(PlanningRelatedCase$inboundSchema))
+    .optional(),
   sourceId: z.string(),
   spatial: z.nullable(z.lazy(() => Spatial$inboundSchema)).optional(),
   spatialFeatures: z.nullable(z.lazy(() => SpatialFeatures$inboundSchema))
@@ -514,6 +593,7 @@ export const PlanningApplication$inboundSchema: z.ZodType<
   status: PlanningApplicationStatus$inboundSchema,
   statusConfidence: z.nullable(z.number()).optional(),
   statusExternal: z.nullable(z.string()).optional(),
+  statusHistory: z.array(PlanningStatusHistory$inboundSchema).optional(),
   type: z.nullable(z.string()).optional(),
   typeConfidence: z.nullable(z.number()).optional(),
   typeExternal: z.nullable(z.string()).optional(),

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

@@ -0,0 +1,49 @@
+/*
+ * 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";
+
+export type PlanningConstraint = {
+  /**
+   * Description of the constraint.
+   */
+  description?: string | null | undefined;
+  /**
+   * Name of the planning constraint.
+   */
+  name?: string | null | undefined;
+  /**
+   * Current status of the constraint.
+   */
+  status?: string | null | undefined;
+  /**
+   * Type or category of constraint (e.g. 'Conservation Area', 'Listed Building').
+   */
+  type?: string | null | undefined;
+};
+
+/** @internal */
+export const PlanningConstraint$inboundSchema: z.ZodType<
+  PlanningConstraint,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
+  status: z.nullable(z.string()).optional(),
+  type: z.nullable(z.string()).optional(),
+});
+
+export function planningConstraintFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningConstraint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningConstraint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningConstraint' from JSON`,
+  );
+}

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

@@ -0,0 +1,69 @@
+/*
+ * 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";
+
+export type PlanningDocument = {
+  /**
+   * ISO 8601 datetime string indicating when this document record was first created in our system.
+   */
+  createdAt: string;
+  /**
+   * Original file name of the document as published by the planning authority (e.g. 'Site_Plan_Rev_A.pdf', 'Decision_Notice.pdf'). The file extension indicates the format (typically PDF, but may include JPEG, PNG, or TIFF for drawings).
+   */
+  fileName: string;
+  /**
+   * File size in bytes, if known. Null if the file size was not available from the source.
+   */
+  fileSize?: number | null | undefined;
+  /**
+   * Unique identifier for the document record.
+   */
+  id: string;
+  /**
+   * Number of pages in the document, if known. Primarily available for PDF documents.
+   */
+  pageCount?: number | null | undefined;
+  /**
+   * UUID of the parent planning application this document belongs to.
+   */
+  planningApplicationId: string;
+  /**
+   * Direct URL to access or download this document from the planning authority's website. Note that council websites may require cookies or session tokens, and URLs may expire over time.
+   */
+  sourceUrl: string;
+  /**
+   * Normalised document type classification. Values: 'application' -- the application form itself. 'decision' -- the formal decision notice. 'appeal' -- appeal-related correspondence. 'certificate' -- ownership or other certificates. 'consultation' -- consultation responses from statutory consultees. 'correspondence' -- letters and emails. 'drawing' -- architectural or technical drawings. 'elevation' -- elevation drawings showing the building's exterior. 'floor_plan' -- internal floor layout plans. 'legal' -- legal agreements (e.g. Section 106). 'location_plan' -- map showing the site in its surroundings. 'notice' -- public notices (e.g. site notice, press notice). 'other' -- documents that do not fit other categories. 'photo' -- photographs of the site or surroundings. 'policy' -- policy statements. 'report' -- officer reports, committee reports, or specialist reports (e.g. ecology, heritage). 'site_map' -- detailed site layout plans. 'statement_case' -- design and access statements or planning statements. 'supporting_document' -- any other supporting documentation. 'unknown' -- document type could not be determined.
+   */
+  type: string;
+};
+
+/** @internal */
+export const PlanningDocument$inboundSchema: z.ZodType<
+  PlanningDocument,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  createdAt: z.string(),
+  fileName: z.string(),
+  fileSize: z.nullable(z.number()).optional(),
+  id: z.string(),
+  pageCount: z.nullable(z.number()).optional(),
+  planningApplicationId: z.string(),
+  sourceUrl: z.string(),
+  type: z.string(),
+});
+
+export function planningDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningDocument' from JSON`,
+  );
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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 { PlanningAgent, PlanningAgent$inboundSchema } from "./planningagent.js";
+import {
+  PlanningApplicant,
+  PlanningApplicant$inboundSchema,
+} from "./planningapplicant.js";
+
+/**
+ * People associated with the application including applicants and planning agents. Contact details (phone, email) are redacted; only names and organisations are included. Null if no applicant or agent data was available.
+ */
+export type PlanningPeople = {
+  /**
+   * Planning agents or consultants acting on behalf of the applicant.
+   */
+  agents?: Array<PlanningAgent> | undefined;
+  /**
+   * People or organisations who submitted the application.
+   */
+  applicants?: Array<PlanningApplicant> | undefined;
+};
+
+/** @internal */
+export const PlanningPeople$inboundSchema: z.ZodType<
+  PlanningPeople,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  agents: z.array(PlanningAgent$inboundSchema).optional(),
+  applicants: z.array(PlanningApplicant$inboundSchema).optional(),
+});
+
+export function planningPeopleFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningPeople, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningPeople$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningPeople' from JSON`,
+  );
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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";
+
+export type PlanningRelatedCase = {
+  /**
+   * Relationship type (e.g. 'appeal', 'amendment', 'linked').
+   */
+  type?: string | null | undefined;
+  /**
+   * URL to the related case, if available.
+   */
+  url?: string | null | undefined;
+  /**
+   * Reference number or identifier of the related case.
+   */
+  value?: string | null | undefined;
+};
+
+/** @internal */
+export const PlanningRelatedCase$inboundSchema: z.ZodType<
+  PlanningRelatedCase,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.nullable(z.string()).optional(),
+  url: z.nullable(z.string()).optional(),
+  value: z.nullable(z.string()).optional(),
+});
+
+export function planningRelatedCaseFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningRelatedCase, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningRelatedCase$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningRelatedCase' from JSON`,
+  );
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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";
+
+export type PlanningStatusHistory = {
+  /**
+   * UUID of the parent planning application this status change belongs to.
+   */
+  applicationId: string;
+  /**
+   * ISO 8601 datetime string indicating when this status change was recorded by the planning authority.
+   */
+  changedAt: string;
+  /**
+   * ISO 8601 datetime string indicating when this status history entry was created in our system.
+   */
+  createdAt: string;
+  /**
+   * Unique identifier for this status history entry.
+   */
+  id: string;
+  /**
+   * The normalised status value at the time of this change. Uses the same values as the application status field.
+   */
+  status: string;
+  /**
+   * The original status text from the planning authority at the time of this change, before normalisation.
+   */
+  statusExternal?: string | null | undefined;
+};
+
+/** @internal */
+export const PlanningStatusHistory$inboundSchema: z.ZodType<
+  PlanningStatusHistory,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  applicationId: z.string(),
+  changedAt: z.string(),
+  createdAt: z.string(),
+  id: z.string(),
+  status: z.string(),
+  statusExternal: z.nullable(z.string()).optional(),
+});
+
+export function planningStatusHistoryFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanningStatusHistory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanningStatusHistory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanningStatusHistory' from JSON`,
+  );
+}

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

@@ -43,7 +43,7 @@ export type PropertyQueryCondition = {
    */
   comparator: Comparator;
   /**
-   * Field to filter on
+   * Field to filter on. Common fields: propertyType, propertyCategory ('residential' or 'commercial'), roomDetails.beds, pricing.currentSale, pricing.currentRent, build.totalFloorArea, epc.rating
    */
   field: string;
   /**

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

@@ -31,7 +31,7 @@ export type PscListResponse = {
   /**
    * Indicates the request was successful.
    */
-  success: boolean;
+  success: true;
   /**
    * Total number of PSC records matching the filters.
    */
@@ -48,7 +48,7 @@ export const PscListResponse$inboundSchema: z.ZodType<
   limit: z.number().int(),
   offset: z.number().int(),
   results: z.array(PscSummary$inboundSchema),
-  success: z.boolean(),
+  success: z.literal(true),
   total: z.number().int(),
 });
 

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

@@ -19,7 +19,7 @@ export type PscResponse = {
   /**
    * Indicates the request was successful.
    */
-  success: boolean;
+  success: true;
 };
 
 /** @internal */
@@ -29,7 +29,7 @@ export const PscResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   result: Psc$inboundSchema,
-  success: z.boolean(),
+  success: z.literal(true),
 });
 
 export function pscResponseFromJSON(

package/src/sdk/property.ts

@@ -121,7 +121,10 @@ export class Property extends ClientSDK {
    * Query properties with advanced filters
    *
    * @remarks
-   * Search for properties using location, price, and other criteria
+   * Search for properties using location, price, and other criteria. By default, only residential properties are returned. To include commercial properties, add a `propertyCategory` condition to your query:
+   *
+   * - Commercial only: `{ "field": "propertyCategory", "comparator": "eq", "value": "commercial" }`
+   * - All categories: omit the default by adding `{ "field": "propertyCategory", "comparator": "exists" }`
    */
   async searchProperties(
     request?: shared.PropertyQueryRequest | undefined,

package/src/sdk/sdk.ts

@@ -9,6 +9,7 @@ import { Avm } from "./avm.js";
 import { Companies } from "./companies.js";
 import { Connectivity } from "./connectivity.js";
 import { Councils } from "./councils.js";
+import { Energy } from "./energy.js";
 import { Epc } from "./epc.js";
 import { Listings } from "./listings.js";
 import { Metrics } from "./metrics.js";
@@ -70,6 +71,11 @@ export class SDK extends ClientSDK {
     return (this._councils ??= new Councils(this._options));
   }
 
+  private _energy?: Energy;
+  get energy(): Energy {
+    return (this._energy ??= new Energy(this._options));
+  }
+
   private _epc?: Epc;
   get epc(): Epc {
     return (this._epc ??= new Epc(this._options));