@vepler/sdk 2.33.0 → 2.37.0

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

@@ -3,7 +3,9 @@
  */
 
 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 {
@@ -11,25 +13,66 @@ import {
   PlanningApplication$inboundSchema,
 } from "./planningapplication.js";
 
+/**
+ * Object type identifier
+ */
+export const PlanningListResponseObject = {
+  List: "list",
+} as const;
+/**
+ * Object type identifier
+ */
+export type PlanningListResponseObject = ClosedEnum<
+  typeof PlanningListResponseObject
+>;
+
+/**
+ * Paginated list response
+ */
 export type PlanningListResponse = {
-  applications: Array<PlanningApplication>;
-  limit: number;
-  offset: number;
-  success: boolean;
-  total: number;
+  /**
+   * Array of items
+   */
+  data: Array<PlanningApplication>;
+  /**
+   * Whether more items exist
+   */
+  hasMore: boolean;
+  /**
+   * Object type identifier
+   */
+  object: PlanningListResponseObject;
+  /**
+   * Total number of items available
+   */
+  totalCount?: number | undefined;
+  /**
+   * URL of the request
+   */
+  url: string;
 };
 
+/** @internal */
+export const PlanningListResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof PlanningListResponseObject
+> = z.nativeEnum(PlanningListResponseObject);
+
 /** @internal */
 export const PlanningListResponse$inboundSchema: z.ZodType<
   PlanningListResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  applications: z.array(PlanningApplication$inboundSchema),
-  limit: z.number(),
-  offset: z.number(),
-  success: z.boolean(),
-  total: z.number(),
+  data: z.array(PlanningApplication$inboundSchema),
+  has_more: z.boolean(),
+  object: PlanningListResponseObject$inboundSchema,
+  total_count: z.number().optional(),
+  url: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+    "total_count": "totalCount",
+  });
 });
 
 export function planningListResponseFromJSON(

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

@@ -4,49 +4,52 @@
 
 import * as z from "zod/v3";
 
+/**
+ * Filter criteria for the search. All specified filters are combined with AND logic (applications must match all filters). Within array filters (e.g. statuses, councils), values are combined with OR logic. Omit or pass an empty object to return all applications.
+ */
 export type PlanningQueryFilters = {
   /**
-   * Filter by appealed date (from)
+   * Include only applications with an appeal lodged on or after this date. Provide an ISO 8601 date string. Only applications that have been appealed will match this filter.
    */
   appealedDateFrom?: string | undefined;
   /**
-   * Filter by appealed date (to)
+   * Include only applications with an appeal lodged on or before this date. Provide an ISO 8601 date string.
    */
   appealedDateTo?: string | undefined;
   /**
-   * Filter by councils/providers
+   * Filter by one or more local planning authority slugs. Values must match the provider field on application objects (e.g. ['lambeth', 'manchester']). Only applications from the specified councils will be returned.
    */
   councils?: Array<string> | undefined;
   /**
-   * Filter by development categories
+   * Filter by one or more development category classifications. Common values: 'Residential', 'Commercial', 'Industrial', 'Mixed Use', 'Infrastructure', 'Change of Use'. Multiple values act as an OR filter.
    */
   developmentCategories?: Array<string> | undefined;
   /**
-   * Filter by application key/reference
+   * Filter by exact application reference number as assigned by the council. Matches the key field on application objects (e.g. '24/00123/FUL'). Returns applications with this exact reference from any council.
    */
   key?: string | undefined;
   /**
-   * Filter by received date (from)
+   * Include only applications received on or after this date. Provide an ISO 8601 date string (e.g. '2024-01-01' or '2024-01-01T00:00:00Z'). Use together with receivedDateTo to define a date range.
    */
   receivedDateFrom?: string | undefined;
   /**
-   * Filter by received date (to)
+   * Include only applications received on or before this date. Provide an ISO 8601 date string (e.g. '2024-12-31' or '2024-12-31T23:59:59Z'). Use together with receivedDateFrom to define a date range.
    */
   receivedDateTo?: string | undefined;
   /**
-   * Filter by application statuses
+   * Filter by one or more normalised application statuses. Accepted values: 'received', 'pending_validation', 'invalid', 'valid', 'under_consideration', 'consultation', 'pending_decision', 'approved', 'rejected', 'withdrawn', 'appeal', 'on_hold', 'expired', 'unknown'. Multiple values act as an OR filter (applications matching any of the specified statuses are returned).
    */
   statuses?: Array<string> | undefined;
   /**
-   * Filter by application types
+   * Filter by one or more normalised application types. Common values: 'Full Planning', 'Householder', 'Listed Building Consent', 'Prior Approval', 'Outline Planning', 'Reserved Matters', 'Discharge of Conditions', 'Tree Works', 'Advertisement Consent', 'Certificate of Lawfulness'. Multiple values act as an OR filter.
    */
   types?: Array<string> | undefined;
   /**
-   * Filter by validated date (from)
+   * Include only applications validated on or after this date. Provide an ISO 8601 date string. Validation is when the council formally registers the application as complete.
    */
   validatedDateFrom?: string | undefined;
   /**
-   * Filter by validated date (to)
+   * Include only applications validated on or before this date. Provide an ISO 8601 date string.
    */
   validatedDateTo?: string | undefined;
 };

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

@@ -10,36 +10,69 @@ import {
   PlanningQueryFilters$outboundSchema,
 } from "./planningqueryfilters.js";
 
-export const SortBy = {
+/**
+ * Field to sort results by. 'receivedDate' -- date the application was received by the council. 'validatedDate' -- date the application was formally validated. 'appealedDate' -- date an appeal was lodged. 'createdAt' -- date the record was created in our system. 'updatedAt' -- date the record was last updated in our system. Defaults to 'receivedDate'.
+ */
+export const PlanningQueryRequestSortBy = {
   ReceivedDate: "receivedDate",
   ValidatedDate: "validatedDate",
   AppealedDate: "appealedDate",
   CreatedAt: "createdAt",
   UpdatedAt: "updatedAt",
 } as const;
-export type SortBy = ClosedEnum<typeof SortBy>;
+/**
+ * Field to sort results by. 'receivedDate' -- date the application was received by the council. 'validatedDate' -- date the application was formally validated. 'appealedDate' -- date an appeal was lodged. 'createdAt' -- date the record was created in our system. 'updatedAt' -- date the record was last updated in our system. Defaults to 'receivedDate'.
+ */
+export type PlanningQueryRequestSortBy = ClosedEnum<
+  typeof PlanningQueryRequestSortBy
+>;
 
-export const SortOrder = {
+/**
+ * Sort direction. 'asc' -- oldest first (ascending chronological order). 'desc' -- newest first (descending chronological order). Defaults to 'desc'.
+ */
+export const PlanningQueryRequestSortOrder = {
   Asc: "asc",
   Desc: "desc",
 } as const;
-export type SortOrder = ClosedEnum<typeof SortOrder>;
+/**
+ * Sort direction. 'asc' -- oldest first (ascending chronological order). 'desc' -- newest first (descending chronological order). Defaults to 'desc'.
+ */
+export type PlanningQueryRequestSortOrder = ClosedEnum<
+  typeof PlanningQueryRequestSortOrder
+>;
 
 export type PlanningQueryRequest = {
+  /**
+   * Maximum number of applications to return per page. Must be between 1 and 100. Defaults to 50. Use together with offset for pagination.
+   */
   limit?: number | undefined;
+  /**
+   * Number of applications to skip before returning results. Use together with limit for pagination. For example, offset=50 with limit=50 returns the second page of results. Defaults to 0.
+   */
   offset?: number | undefined;
+  /**
+   * Filter criteria for the search. All specified filters are combined with AND logic (applications must match all filters). Within array filters (e.g. statuses, councils), values are combined with OR logic. Omit or pass an empty object to return all applications.
+   */
   query?: PlanningQueryFilters | undefined;
-  sortBy?: SortBy | undefined;
-  sortOrder?: SortOrder | undefined;
+  /**
+   * Field to sort results by. 'receivedDate' -- date the application was received by the council. 'validatedDate' -- date the application was formally validated. 'appealedDate' -- date an appeal was lodged. 'createdAt' -- date the record was created in our system. 'updatedAt' -- date the record was last updated in our system. Defaults to 'receivedDate'.
+   */
+  sortBy?: PlanningQueryRequestSortBy | undefined;
+  /**
+   * Sort direction. 'asc' -- oldest first (ascending chronological order). 'desc' -- newest first (descending chronological order). Defaults to 'desc'.
+   */
+  sortOrder?: PlanningQueryRequestSortOrder | undefined;
 };
 
 /** @internal */
-export const SortBy$outboundSchema: z.ZodNativeEnum<typeof SortBy> = z
-  .nativeEnum(SortBy);
+export const PlanningQueryRequestSortBy$outboundSchema: z.ZodNativeEnum<
+  typeof PlanningQueryRequestSortBy
+> = z.nativeEnum(PlanningQueryRequestSortBy);
 
 /** @internal */
-export const SortOrder$outboundSchema: z.ZodNativeEnum<typeof SortOrder> = z
-  .nativeEnum(SortOrder);
+export const PlanningQueryRequestSortOrder$outboundSchema: z.ZodNativeEnum<
+  typeof PlanningQueryRequestSortOrder
+> = z.nativeEnum(PlanningQueryRequestSortOrder);
 
 /** @internal */
 export type PlanningQueryRequest$Outbound = {
@@ -59,8 +92,8 @@ export const PlanningQueryRequest$outboundSchema: z.ZodType<
   limit: z.number().default(50),
   offset: z.number().default(0),
   query: PlanningQueryFilters$outboundSchema.optional(),
-  sortBy: SortBy$outboundSchema.default("receivedDate"),
-  sortOrder: SortOrder$outboundSchema.default("desc"),
+  sortBy: PlanningQueryRequestSortBy$outboundSchema.default("receivedDate"),
+  sortOrder: PlanningQueryRequestSortOrder$outboundSchema.default("desc"),
 });
 
 export function planningQueryRequestToJSON(

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

@@ -0,0 +1,132 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * WGS84 coordinate pair
+ */
+export type PostcodeAddressCoordinates = {
+  /**
+   * Latitude in decimal degrees
+   */
+  lat: number;
+  /**
+   * Longitude in decimal degrees
+   */
+  lng: number;
+};
+
+/**
+ * Matched address (if found)
+ */
+export type PostcodeAddress = {
+  /**
+   * AddressBase classification code
+   */
+  classificationCode?: string | undefined;
+  /**
+   * WGS84 coordinate pair
+   */
+  coordinates?: PostcodeAddressCoordinates | undefined;
+  /**
+   * County
+   */
+  county: string;
+  /**
+   * Distance from query point in metres (reverse geocode only)
+   */
+  distanceMetres?: number | undefined;
+  /**
+   * Single-line formatted address
+   */
+  formatted: string;
+  /**
+   * Primary address line
+   */
+  line1: string;
+  /**
+   * Secondary address line
+   */
+  line2: string;
+  /**
+   * Tertiary address line
+   */
+  line3: string;
+  /**
+   * Post town (uppercase)
+   */
+  postTown: string;
+  /**
+   * Full postcode
+   */
+  postcode: string;
+  /**
+   * Unique Property Reference Number
+   */
+  uprn: string;
+};
+
+/** @internal */
+export const PostcodeAddressCoordinates$inboundSchema: z.ZodType<
+  PostcodeAddressCoordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lng: z.number(),
+});
+
+export function postcodeAddressCoordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<PostcodeAddressCoordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostcodeAddressCoordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostcodeAddressCoordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostcodeAddress$inboundSchema: z.ZodType<
+  PostcodeAddress,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  classification_code: z.string().optional(),
+  coordinates: z.lazy(() => PostcodeAddressCoordinates$inboundSchema)
+    .optional(),
+  county: z.string(),
+  distance_metres: z.number().optional(),
+  formatted: z.string(),
+  line_1: z.string(),
+  line_2: z.string(),
+  line_3: z.string(),
+  post_town: z.string(),
+  postcode: z.string(),
+  uprn: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "classification_code": "classificationCode",
+    "distance_metres": "distanceMetres",
+    "line_1": "line1",
+    "line_2": "line2",
+    "line_3": "line3",
+    "post_town": "postTown",
+  });
+});
+
+export function postcodeAddressFromJSON(
+  jsonString: string,
+): SafeParseResult<PostcodeAddress, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostcodeAddress$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostcodeAddress' from JSON`,
+  );
+}

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

@@ -0,0 +1,88 @@
+/*
+ * 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";
+import {
+  PostcodeAddress,
+  PostcodeAddress$inboundSchema,
+} from "./postcodeaddress.js";
+
+export const PostcodeLookupResponseObject = {
+  List: "list",
+} as const;
+export type PostcodeLookupResponseObject = ClosedEnum<
+  typeof PostcodeLookupResponseObject
+>;
+
+export type PostcodeLookupResponse = {
+  /**
+   * Addresses at this postcode
+   */
+  data: Array<PostcodeAddress>;
+  /**
+   * Geographic context (when include=geography)
+   */
+  geography?: GeographicContext | undefined;
+  /**
+   * Whether more results exist
+   */
+  hasMore: boolean;
+  object: PostcodeLookupResponseObject;
+  /**
+   * Formatted postcode
+   */
+  postcode: string;
+  /**
+   * Total addresses at this postcode
+   */
+  totalCount: number;
+  /**
+   * Request URL
+   */
+  url: string;
+};
+
+/** @internal */
+export const PostcodeLookupResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof PostcodeLookupResponseObject
+> = z.nativeEnum(PostcodeLookupResponseObject);
+
+/** @internal */
+export const PostcodeLookupResponse$inboundSchema: z.ZodType<
+  PostcodeLookupResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(PostcodeAddress$inboundSchema),
+  geography: GeographicContext$inboundSchema.optional(),
+  has_more: z.boolean(),
+  object: PostcodeLookupResponseObject$inboundSchema,
+  postcode: z.string(),
+  total_count: z.number().int(),
+  url: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+    "total_count": "totalCount",
+  });
+});
+
+export function postcodeLookupResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostcodeLookupResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostcodeLookupResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostcodeLookupResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,152 @@
+/*
+ * 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";
+
+/**
+ * Statistical area codes
+ */
+export type Codes = {
+  lsoa?: string | undefined;
+  msoa?: string | undefined;
+  ward?: string | undefined;
+};
+
+/**
+ * WGS84 coordinate pair
+ */
+export type PostcodeValidationResponseCoordinates = {
+  /**
+   * Latitude in decimal degrees
+   */
+  lat: number;
+  /**
+   * Longitude in decimal degrees
+   */
+  lng: number;
+};
+
+export const PostcodeValidationResponseObject = {
+  PostcodeValidation: "postcode_validation",
+} as const;
+export type PostcodeValidationResponseObject = ClosedEnum<
+  typeof PostcodeValidationResponseObject
+>;
+
+export type PostcodeValidationResponse = {
+  /**
+   * Whether the postcode is currently in use
+   */
+  active?: boolean | undefined;
+  /**
+   * Statistical area codes
+   */
+  codes?: Codes | undefined;
+  /**
+   * WGS84 coordinate pair
+   */
+  coordinates?: PostcodeValidationResponseCoordinates | undefined;
+  /**
+   * Country name
+   */
+  country?: string | undefined;
+  /**
+   * Whether the postcode has a valid format (returned when ES lookup fails)
+   */
+  formatValid?: boolean | undefined;
+  object: PostcodeValidationResponseObject;
+  /**
+   * Input postcode (normalised)
+   */
+  postcode: string;
+  /**
+   * Region name
+   */
+  region?: string | undefined;
+  /**
+   * Whether the postcode is valid and active
+   */
+  valid: boolean;
+};
+
+/** @internal */
+export const Codes$inboundSchema: z.ZodType<Codes, z.ZodTypeDef, unknown> = z
+  .object({
+    lsoa: z.string().optional(),
+    msoa: z.string().optional(),
+    ward: z.string().optional(),
+  });
+
+export function codesFromJSON(
+  jsonString: string,
+): SafeParseResult<Codes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Codes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Codes' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostcodeValidationResponseCoordinates$inboundSchema: z.ZodType<
+  PostcodeValidationResponseCoordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lng: z.number(),
+});
+
+export function postcodeValidationResponseCoordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<PostcodeValidationResponseCoordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PostcodeValidationResponseCoordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostcodeValidationResponseCoordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostcodeValidationResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof PostcodeValidationResponseObject
+> = z.nativeEnum(PostcodeValidationResponseObject);
+
+/** @internal */
+export const PostcodeValidationResponse$inboundSchema: z.ZodType<
+  PostcodeValidationResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  active: z.boolean().optional(),
+  codes: z.lazy(() => Codes$inboundSchema).optional(),
+  coordinates: z.lazy(() => PostcodeValidationResponseCoordinates$inboundSchema)
+    .optional(),
+  country: z.string().optional(),
+  format_valid: z.boolean().optional(),
+  object: PostcodeValidationResponseObject$inboundSchema,
+  postcode: z.string(),
+  region: z.string().optional(),
+  valid: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    "format_valid": "formatValid",
+  });
+});
+
+export function postcodeValidationResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostcodeValidationResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostcodeValidationResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostcodeValidationResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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";
+
+/**
+ * A historical company name with the dates it was in effect
+ */
+export type PreviousName = {
+  /**
+   * Date when this name ceased to be used (i.e. when a subsequent name change took effect). ISO 8601 format.
+   */
+  ceasedOn?: Date | null | undefined;
+  /**
+   * Date when this name became effective, i.e. when the company started trading under this name. ISO 8601 format.
+   */
+  effectiveFrom?: Date | null | undefined;
+  /**
+   * The previous company name exactly as it appeared on the register.
+   */
+  name: string;
+};
+
+/** @internal */
+export const PreviousName$inboundSchema: z.ZodType<
+  PreviousName,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ceasedOn: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  effectiveFrom: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  name: z.string(),
+});
+
+export function previousNameFromJSON(
+  jsonString: string,
+): SafeParseResult<PreviousName, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PreviousName$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PreviousName' from JSON`,
+  );
+}