@vepler/sdk 3.3.0 → 5.28.1

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

@@ -6,7 +6,7 @@ import * as z from "zod/v3";
 import { ClosedEnum } from "../../types/enums.js";
 
 /**
- * Comparison operator. Range operators (gt/gte/lt/lte) apply to numeric and date fields.
+ * How `value` is compared with the field. `in` and `nin` take an array of values and every other comparator takes a single value; `ne` and `nin` also keep records where the field has no value.
  */
 export const TransactionQueryConditionComparator = {
   Eq: "eq",
@@ -19,7 +19,7 @@ export const TransactionQueryConditionComparator = {
   Nin: "nin",
 } as const;
 /**
- * Comparison operator. Range operators (gt/gte/lt/lte) apply to numeric and date fields.
+ * How `value` is compared with the field. `in` and `nin` take an array of values and every other comparator takes a single value; `ne` and `nin` also keep records where the field has no value.
  */
 export type TransactionQueryConditionComparator = ClosedEnum<
   typeof TransactionQueryConditionComparator
@@ -28,7 +28,7 @@ export type TransactionQueryConditionComparator = ClosedEnum<
 export type TransactionQueryCondition4 = string | number | boolean;
 
 /**
- * Value to compare against. Use an array with 'in'/'nin'; a single value for all other comparators.
+ * The value to compare against. Use an array with `in` and `nin`, and a single value with every other comparator. A `price.amount` value must be a non-negative whole number in minor currency units.
  */
 export type TransactionQueryConditionValue =
   | string
@@ -38,15 +38,15 @@ export type TransactionQueryConditionValue =
 
 export type TransactionQueryCondition = {
   /**
-   * Comparison operator. Range operators (gt/gte/lt/lte) apply to numeric and date fields.
+   * How `value` is compared with the field. `in` and `nin` take an array of values and every other comparator takes a single value; `ne` and `nin` also keep records where the field has no value.
    */
   comparator: TransactionQueryConditionComparator;
   /**
-   * Field to filter on. Examples: country, kind, tenure, propertyType, price.amount, date, address.outcode.
+   * The field to filter on. Supported paths are `country`, `kind`, `tenure`, `propertyType`, `newBuild`, `provider`, `price.amount`, `date`, `address.postcode`, `address.outcode` and `location.uprn`.
    */
   field: string;
   /**
-   * Value to compare against. Use an array with 'in'/'nin'; a single value for all other comparators.
+   * The value to compare against. Use an array with `in` and `nin`, and a single value with every other comparator. A `price.amount` value must be a non-negative whole number in minor currency units.
    */
   value: string | number | boolean | Array<string | number | boolean>;
 };

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

@@ -11,7 +11,7 @@ import {
 
 export type TransactionQueryGroup = {
   /**
-   * Conditions within this group.
+   * The conditions in this group. A record has to satisfy all of them.
    */
   conditions: Array<TransactionQueryCondition>;
 };

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

@@ -11,14 +11,14 @@ import {
 } from "./transactionquerygroup.js";
 
 /**
- * How the groups in this block are combined. Conditions within a single group are always AND'd.
+ * How the groups in this block combine. Conditions within a single group always combine with AND.
  */
 export const TransactionQueryOperatorOperator = {
   And: "AND",
   Or: "OR",
 } as const;
 /**
- * How the groups in this block are combined. Conditions within a single group are always AND'd.
+ * How the groups in this block combine. Conditions within a single group always combine with AND.
  */
 export type TransactionQueryOperatorOperator = ClosedEnum<
   typeof TransactionQueryOperatorOperator
@@ -26,11 +26,11 @@ export type TransactionQueryOperatorOperator = ClosedEnum<
 
 export type TransactionQueryOperator = {
   /**
-   * Condition groups.
+   * The groups of conditions this block combines.
    */
   groups: Array<TransactionQueryGroup>;
   /**
-   * How the groups in this block are combined. Conditions within a single group are always AND'd.
+   * How the groups in this block combine. Conditions within a single group always combine with AND.
    */
   operator: TransactionQueryOperatorOperator;
 };

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

@@ -16,33 +16,33 @@ import {
 } from "./transactionqueryoperator.js";
 
 /**
- * Comma-separated string or array of fields to include (sparse fieldset).
+ * Top-level fields to return for each transaction, as an array or a comma-separated string. `object` and `id` are always returned.
  */
 export type TransactionQueryRequestAttributes = string | Array<string>;
 
 /**
- * Field to sort by (whitelisted).
+ * Which field to order by.
  */
 export const TransactionQueryRequestField = {
   Date: "date",
   PriceAmount: "price.amount",
 } as const;
 /**
- * Field to sort by (whitelisted).
+ * Which field to order by.
  */
 export type TransactionQueryRequestField = ClosedEnum<
   typeof TransactionQueryRequestField
 >;
 
 /**
- * Sort direction.
+ * Which direction to order in.
  */
 export const TransactionQueryRequestOrder = {
   Asc: "asc",
   Desc: "desc",
 } as const;
 /**
- * Sort direction.
+ * Which direction to order in.
  */
 export type TransactionQueryRequestOrder = ClosedEnum<
   typeof TransactionQueryRequestOrder
@@ -50,41 +50,41 @@ export type TransactionQueryRequestOrder = ClosedEnum<
 
 export type TransactionQueryRequestSort = {
   /**
-   * Field to sort by (whitelisted).
+   * Which field to order by.
    */
   field: TransactionQueryRequestField;
   /**
-   * Sort direction.
+   * Which direction to order in.
    */
   order: TransactionQueryRequestOrder;
 };
 
 /**
- * Advanced property-transaction search. Postgres-backed, with an Elasticsearch-shaped contract.
+ * Search criteria for property transactions: the areas, field conditions, ordering, fields and page size to search with.
  */
 export type TransactionQueryRequest = {
   /**
-   * Geographic areas, combined with OR.
+   * Areas to search within. A transaction inside any of them matches.
    */
   area?: Array<TransactionAreaFilter> | undefined;
   /**
-   * Comma-separated string or array of fields to include (sparse fieldset).
+   * Top-level fields to return for each transaction, as an array or a comma-separated string. `object` and `id` are always returned.
    */
   attributes?: string | Array<string> | undefined;
   /**
-   * Opaque pagination cursor from a previous response's `next_cursor`. Use instead of an offset.
+   * Opaque cursor from the `next_cursor` of a previous response. Send it with the same `sort` as the request that produced it; a cursor from a different sort is ignored.
    */
   cursor?: string | undefined;
   /**
-   * Maximum results per page (1–100).
+   * Maximum number of transactions to return. Defaults to 25. Minimum 1, maximum 100.
    */
   limit?: number | undefined;
   /**
-   * Structured filter. Top-level blocks are combined with AND (each is an additional constraint); within a block, groups combine by the block operator, and conditions within a group are AND'd.
+   * Structured filter. Blocks at the top level combine with AND, each one narrowing the result further; within a block the groups combine by the block's operator, and the conditions in a group combine with AND.
    */
   query?: Array<TransactionQueryOperator> | undefined;
   /**
-   * Sort configuration (max 3 fields). Defaults to date descending.
+   * How to order the results. Up to three entries are accepted, and the first is applied. Defaults to `date` descending.
    */
   sort?: Array<TransactionQueryRequestSort> | undefined;
 };

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

@@ -18,16 +18,16 @@ export type TransactionsListResponseObject = ClosedEnum<
 >;
 
 /**
- * Cursor-paginated list of transactions (Stripe-style envelope).
+ * One page of transactions, with the cursor needed to fetch the next.
  */
 export type TransactionsListResponse = {
   data: Array<Transaction>;
   /**
-   * Whether more results exist beyond this page.
+   * True when further results exist beyond this page.
    */
   hasMore: boolean;
   /**
-   * Opaque cursor for the next page; null when there are no more results.
+   * Opaque cursor for the next page. Null when this is the last page.
    */
   nextCursor: string | null;
   object: TransactionsListResponseObject;

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

@@ -16,23 +16,23 @@ import {
 } from "./trendsignificance.js";
 
 /**
- * Temporal trend on a score
+ * How the score has changed over time.
  */
 export type Trend = {
   /**
-   * Change in score per year, sign matches direction
+   * Change in the score per year, signed to match `direction`.
    */
   changePerYear?: number | undefined;
   /**
-   * Direction of change over time
+   * Which way the score has moved over time.
    */
   direction: TrendDirection;
   /**
-   * Statistical or practical significance of the trend
+   * How significant the movement is, statistically or practically.
    */
   significance?: TrendSignificance | undefined;
   /**
-   * Number of years observed when computing this trend
+   * Number of years the movement was measured over.
    */
   windowYears?: number | undefined;
 };

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

@@ -7,7 +7,7 @@ import * as openEnums from "../../types/enums.js";
 import { OpenEnum } from "../../types/enums.js";
 
 /**
- * Direction of change over time
+ * Which way the score has moved over time.
  */
 export const TrendDirection = {
   Up: "up",
@@ -15,7 +15,7 @@ export const TrendDirection = {
   Stable: "stable",
 } as const;
 /**
- * Direction of change over time
+ * Which way the score has moved over time.
  */
 export type TrendDirection = OpenEnum<typeof TrendDirection>;
 

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

@@ -7,7 +7,7 @@ import * as openEnums from "../../types/enums.js";
 import { OpenEnum } from "../../types/enums.js";
 
 /**
- * Statistical or practical significance of the trend
+ * How significant the movement is, statistically or practically.
  */
 export const TrendSignificance = {
   High: "high",
@@ -15,7 +15,7 @@ export const TrendSignificance = {
   Low: "low",
 } as const;
 /**
- * Statistical or practical significance of the trend
+ * How significant the movement is, statistically or practically.
  */
 export type TrendSignificance = OpenEnum<typeof TrendSignificance>;
 

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

@@ -8,21 +8,29 @@ 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 {
+  AddressContext,
+  AddressContext$inboundSchema,
+} from "./addresscontext.js";
 import {
   GeographicContext,
   GeographicContext$inboundSchema,
 } from "./geographiccontext.js";
+import {
+  RoyalMailAddress,
+  RoyalMailAddress$inboundSchema,
+} from "./royalmailaddress.js";
 
 /**
- * WGS84 coordinates
+ * Position of this address.
  */
 export type UprnLookupResponseCoordinates = {
   /**
-   * Latitude in decimal degrees
+   * Latitude in WGS84 decimal degrees.
    */
   lat: number;
   /**
-   * Longitude in decimal degrees
+   * Longitude in WGS84 decimal degrees.
    */
   lng: number;
 };
@@ -36,48 +44,51 @@ export type UprnLookupResponseObject = ClosedEnum<
 
 export type UprnLookupResponse = {
   /**
-   * AddressBase classification code
+   * AddressBase classification code for how the property is used.
    */
   classificationCode?: string | undefined;
+  context?: AddressContext | undefined;
   /**
-   * WGS84 coordinates
+   * Position of this address.
    */
   coordinates?: UprnLookupResponseCoordinates | undefined;
   /**
-   * County
+   * Nation this address sits in, as a slug: `england`, `scotland`, `wales` or `northern-ireland`. Null or absent when it is not known.
    */
-  county: string;
+  country?: string | null | undefined;
   /**
-   * Single-line formatted address
+   * Ceremonial county for this address's postcode, from OS Boundary-Line. Empty when it is not known; see `PostcodeAddress.county`.
    */
-  formatted: string;
+  county: string;
   /**
-   * Geographic context (when include=geography)
+   * The whole address on one line, with the parts joined by commas.
    */
+  formatted: string;
   geography?: GeographicContext | undefined;
   /**
-   * Primary address line
+   * First line of the address: organisation, sub-building, building and street.
    */
   line1: string;
   /**
-   * Secondary address line
+   * Second line of the address, carrying the Ordnance Survey locality. Empty when there is none.
    */
   line2: string;
   /**
-   * Tertiary address line
+   * Third line of the address. Empty when the address has no third line.
    */
   line3: string;
   object: UprnLookupResponseObject;
   /**
-   * Post town
+   * The settlement the street sits in, as Ordnance Survey names it. For the postal town read `royal_mail.post_town`.
    */
   postTown: string;
   /**
-   * Postcode
+   * Full postcode of the address.
    */
   postcode: string;
+  royalMail?: RoyalMailAddress | undefined;
   /**
-   * Unique Property Reference Number
+   * The Unique Property Reference Number (UPRN).
    */
   uprn: string;
 };
@@ -114,8 +125,10 @@ export const UprnLookupResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   classification_code: z.string().optional(),
+  context: AddressContext$inboundSchema.optional(),
   coordinates: z.lazy(() => UprnLookupResponseCoordinates$inboundSchema)
     .optional(),
+  country: z.nullable(z.string()).optional(),
   county: z.string(),
   formatted: z.string(),
   geography: GeographicContext$inboundSchema.optional(),
@@ -125,6 +138,7 @@ export const UprnLookupResponse$inboundSchema: z.ZodType<
   object: UprnLookupResponseObject$inboundSchema,
   post_town: z.string(),
   postcode: z.string(),
+  royal_mail: RoyalMailAddress$inboundSchema.optional(),
   uprn: z.string(),
 }).transform((v) => {
   return remap$(v, {
@@ -133,6 +147,7 @@ export const UprnLookupResponse$inboundSchema: z.ZodType<
     "line_2": "line2",
     "line_3": "line3",
     "post_town": "postTown",
+    "royal_mail": "royalMail",
   });
 });
 

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

@@ -7,7 +7,7 @@ import * as openEnums from "../../types/enums.js";
 import { OpenEnum } from "../../types/enums.js";
 
 /**
- * Magnitude of expected effect on property value
+ * How much the risk is expected to move the value of a property.
  */
 export const ValueImpact = {
   None: "none",
@@ -17,7 +17,7 @@ export const ValueImpact = {
   Major: "major",
 } as const;
 /**
- * Magnitude of expected effect on property value
+ * How much the risk is expected to move the value of a property.
  */
 export type ValueImpact = OpenEnum<typeof ValueImpact>;
 

package/src/sdk/planning.ts

@@ -12,10 +12,10 @@ import { unwrapAsync } from "./types/fp.js";
 
 export class Planning extends ClientSDK {
   /**
-   * Get planning applications by application IDs
+   * Get planning applications by ID
    *
    * @remarks
-   * Retrieve one or more planning applications by their internal UUIDs. Provide up to 100 comma-separated application IDs in the path. Returns the matching applications in a paginated list response. If you have council reference numbers rather than UUIDs, use the GET /sources/{sourceIds} endpoint instead. Use ?include= to attach optional expansions (comma-separated): 'extractions' (structured, citation-backed extractions), 'images' (a renderable image gallery), 'content' (fileUrl + ocrUrl on each document), 'enrichment' (AI classification reasoning and document summaries).
+   * Returns planning applications by the identifiers this API assigns to them. Give up to 100 identifiers in the path, separated by commas; identifiers that match nothing are left out of the response rather than reported. If you hold council reference numbers instead, use GET /sources/{sourceIds}. Set the include parameter to attach optional expansions, comma-separated: 'extractions' for the structured, quote-backed extractions, 'images' for the image gallery, 'content' for each document's file and text addresses, and 'enrichment' for the classification reasoning and document summaries.
    */
   async getPlanningApplications(
     request: operations.GetPlanningApplicationsRequest,
@@ -29,10 +29,10 @@ export class Planning extends ClientSDK {
   }
 
   /**
-   * Get planning applications by source IDs
+   * Get planning applications by source ID
    *
    * @remarks
-   * Retrieve one or more planning applications by their source identifiers. Each source ID uses the format 'provider::key' where provider is the council slug and key is the council's reference number (e.g. 'lambeth::24/00123/FUL'). Provide up to 100 comma-separated source IDs in the path. This is the recommended lookup method when you know the council and application reference number. Use ?include= to attach optional expansions (comma-separated): 'extractions' (structured, citation-backed extractions), 'images' (a renderable image gallery), 'content' (fileUrl + ocrUrl on each document), 'enrichment' (AI classification reasoning and document summaries).
+   * Returns planning applications by their source identifiers, each of the form `provider::key`, where provider is the council slug and key is that council's own reference number, for example 'lambeth::24/00123/FUL'. Give up to 100 in the path, separated by commas; identifiers that match nothing are left out of the response rather than reported. This is the lookup to use when you know the council and its reference number. Set the include parameter to attach optional expansions, comma-separated: 'extractions' for the structured, quote-backed extractions, 'images' for the image gallery, 'content' for each document's file and text addresses, and 'enrichment' for the classification reasoning and document summaries.
    */
   async getPlanningApplicationsBySource(
     request: operations.GetPlanningApplicationsBySourceRequest,
@@ -46,10 +46,10 @@ export class Planning extends ClientSDK {
   }
 
   /**
-   * Query planning applications with advanced filters
+   * Search planning applications
    *
    * @remarks
-   * Search for planning applications using a combination of filters including council, status, type, development category, and date ranges. Use the `near` filter ({ lat, lng, radiusM }) to retrieve applications around a point — the primary way to find a property's planning context; results come back closest-first with `distance` (metres) populated. Pass `include` (any of `["extractions", "images", "content", "enrichment"]`) to attach structured citation-backed extractions, a renderable image gallery, document fileUrl/ocrUrl, and/or AI classification reasoning. Filters within the query object are combined with AND logic, whilst array values within a single filter use OR logic. Results are paginated and can be sorted by any date field (the `near` filter overrides sort with closest-first). Supports up to 100 results per page.
+   * Searches planning applications by council, status, type, development category and date range. Use the `near` filter (lat, lng and radiusM) to find the applications around a point: matches come back closest first, each carrying `distance` in metres, and that ordering replaces sortBy and sortOrder. Separate filters are combined with AND, while several values inside one array filter are combined with OR. Results are paginated at up to 100 per page, and `include` attaches any of the extractions, the image gallery, document file and text addresses, or the classification reasoning to each application returned.
    */
   async searchPlanningApplications(
     request?: shared.PlanningQueryRequest | undefined,

package/src/sdk/poi.ts

@@ -16,7 +16,7 @@ export class Poi extends ClientSDK {
    * Find nearest points of interest
    *
    * @remarks
-   * Find the nearest points of interest to a given location. Filter by POI category and optionally include routing distances.
+   * Returns the points of interest closest to a location, nearest first, with the straight-line distance to each. Narrow the search with `types`, and add distances and times along roads and paths with `routing`.
    */
   async getNearestPOI(
     request: operations.GetNearestPOIRequest,
@@ -30,10 +30,10 @@ export class Poi extends ClientSDK {
   }
 
   /**
-   * Get POIs from multiple tiles
+   * Get points of interest from several map tiles
    *
    * @remarks
-   * Retrieve points of interest from multiple map tiles in a single request. Tiles specified as comma-separated z/x/y values.
+   * Returns the points of interest for several tiles in one request, given as comma-separated `z/x/y` coordinates. Each tile is reported separately, so a tile that cannot be produced carries its own error rather than failing the request.
    */
   async getPOIMultipleTiles(
     request: operations.GetPOIMultipleTilesRequest,
@@ -47,10 +47,10 @@ export class Poi extends ClientSDK {
   }
 
   /**
-   * Get POIs in a map tile
+   * Get points of interest in a map tile
    *
    * @remarks
-   * Retrieve points of interest within a map tile specified by z/x/y coordinates. Supports GeoJSON and MVT formats.
+   * Returns the points of interest inside one slippy map tile, addressed by its zoom, column and row. With `format=geojson` the tile comes back as JSON holding a GeoJSON FeatureCollection; with `format=mvt` it comes back as a binary Mapbox Vector Tile.
    */
   async getPOITile(
     request: operations.GetPOITileRequest,

package/src/sdk/property.ts

@@ -7,6 +7,7 @@ import { propertyGetProperties } from "../funcs/propertyGetProperties.js";
 import { propertyGetPropertiesByLocation } from "../funcs/propertyGetPropertiesByLocation.js";
 import { propertyGetPropertiesBySlugs } from "../funcs/propertyGetPropertiesBySlugs.js";
 import { propertyGetPropertiesBySource } from "../funcs/propertyGetPropertiesBySource.js";
+import { propertyGetPropertyAttributes } from "../funcs/propertyGetPropertyAttributes.js";
 import { propertyGetPropertyTiles } from "../funcs/propertyGetPropertyTiles.js";
 import { propertySearchProperties } from "../funcs/propertySearchProperties.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
@@ -16,10 +17,10 @@ import { unwrapAsync } from "./types/fp.js";
 
 export class Property extends ClientSDK {
   /**
-   * Aggregate property statistics within a geographic area
+   * Aggregate property statistics for an area
    *
    * @remarks
-   * Execute real-time aggregations (counts, averages, distributions) over property data within a specified geographic boundary. Limited to areas ≤500 km² for reliable performance. Returns computed statistics without individual property documents.
+   * Counts, averages and distributions calculated over the properties in an area, without returning the properties themselves. Use it for market summaries and charts where a full result set would be wasteful. The areas may cover 500 km² in total at most, and a request may carry up to 10 aggregations.
    */
   async aggregateProperties(
     request?: shared.PropertyAggregateRequest | undefined,
@@ -33,10 +34,10 @@ export class Property extends ClientSDK {
   }
 
   /**
-   * Get properties by property IDs
+   * Get properties by property ID
    *
    * @remarks
-   * Retrieve property data using comma-separated property identifiers
+   * Returns one property per property ID supplied, separated by commas. Reach for it when you already hold property IDs from an earlier response; look properties up by location ID when you hold a UPRN instead.
    */
   async getProperties(
     request: operations.GetPropertiesRequest,
@@ -50,10 +51,10 @@ export class Property extends ClientSDK {
   }
 
   /**
-   * Get properties by location IDs
+   * Get properties by location ID
    *
    * @remarks
-   * Retrieve property data using comma-separated location identifiers
+   * Returns one property per location ID supplied, which in Great Britain is the Unique Property Reference Number (UPRN). Pass several at once by separating them with commas. Use `attributes` to choose what comes back; without it you get the default set of identity and address fields. Add `monitor` to also monitor the properties it returns, for a whole number of months or `true` for one; the response then carries a short `monitoring` object and is otherwise unchanged.
    */
   async getPropertiesByLocation(
     request: operations.GetPropertiesByLocationRequest,
@@ -67,10 +68,10 @@ export class Property extends ClientSDK {
   }
 
   /**
-   * Get properties by slugs
+   * Get properties by slug
    *
    * @remarks
-   * Retrieve property data using an array of property slugs
+   * Returns the properties matching a list of address slugs, the URL-safe form carried in each property's `slug` field. Up to 1,000 slugs per request.
    */
   async getPropertiesBySlugs(
     request?: shared.PropertyBySlugsRequest | undefined,
@@ -84,10 +85,10 @@ export class Property extends ClientSDK {
   }
 
   /**
-   * Get properties by source IDs
+   * Get properties by source ID
    *
    * @remarks
-   * Retrieve property data using comma-separated source identifiers (e.g., provider-a::123)
+   * Returns the property behind each source ID supplied, separated by commas. A source ID is written `provider::key`, naming the provider and its own identifier for the record, so this is the way back from a provider's listing reference to the property it belongs to.
    */
   async getPropertiesBySource(
     request: operations.GetPropertiesBySourceRequest,
@@ -100,11 +101,26 @@ export class Property extends ClientSDK {
     ));
   }
 
+  /**
+   * Get the property attribute catalogue
+   *
+   * @remarks
+   * Lists every attribute the property endpoints can return, with its dotted path, type, the billing tier it puts a request into and any extended permission it needs, alongside the field names, comparators and sort fields that `POST /v1/property/query` accepts. Read it to build a request without guessing, and to price one before sending it. This endpoint is free to call.
+   */
+  async getPropertyAttributes(
+    options?: RequestOptions,
+  ): Promise<shared.PropertyAttributeCatalogue> {
+    return unwrapAsync(propertyGetPropertyAttributes(
+      this,
+      options,
+    ));
+  }
+
   /**
    * Get property map tiles
    *
    * @remarks
-   * Retrieve property data as Mapbox Vector Tiles (MVT) for map visualisation. Supports up to 10,000 properties per tile via Elasticsearch native MVT. Filter properties using the query parameter with PropertyQueryOperator format. Tiles follow the standard Web Mercator (EPSG:3857) z/x/y scheme.
+   * Returns properties as a Mapbox Vector Tile, ready to drop into a map style. Tiles follow the standard Web Mercator z/x/y scheme, so a map library requests them by URL template. A tile carries up to 10,000 properties; use `mode=density` at low zoom, where a grid of counts replaces the individual properties and nothing is dropped. Narrow what a tile draws with `query` and `area`, and choose what each feature carries with `attributes`.
    */
   async getPropertyTiles(
     request: operations.GetPropertyTilesRequest,
@@ -118,13 +134,10 @@ export class Property extends ClientSDK {
   }
 
   /**
-   * Query properties with advanced filters
+   * Search properties
    *
    * @remarks
-   * 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" }`
+   * Searches properties inside one or more areas, narrowed by any combination of attributes: price, bedrooms, energy rating, market status and the rest of the catalogue at `GET /v1/property/attributes`. Only residential properties are returned, and a `propertyCategory` condition cannot widen that, so a query asking for commercial properties matches nothing. A page may hold up to 10,000 properties, and `limit` plus `offset` may not exceed 10,000 either, so reach a deeper result set by narrowing the area rather than paging on; a request beyond that depth is rejected instead of being quietly answered with a different page. The optional `monitor` parameter registers every property the query matches, which is the whole match set rather than the page returned, for monitoring billed monthly per property. That registration runs in the background and needs an active property_monitoring licence grant, and the response carries a `monitoring` receipt describing what happened to it.
    */
   async searchProperties(
     request?: shared.PropertyQueryRequest | undefined,

package/src/sdk/prosperity.ts

@@ -13,11 +13,7 @@ export class Prosperity extends ClientSDK {
    * Get the Prosperity Index for one or more small areas
    *
    * @remarks
-   * Returns the Vepler Prosperity Index for one or more small-area codes — a composite 0-100 economic-prosperity score with national decile (1-10) and percentile. Pass a single code (e.g. `E01000001`) or a comma-separated list (up to 100). Each result is self-describing, carrying its own `geographicCode`, so multi-code lookups can be mapped back by the caller.
-   *
-   * The score breaks down into four weighted dimensions (income, housing, employment, living standards) and the curated underlying indicators (19 ONS/MHCLG measures) that feed them, each with display value, national median/mean, percentile and source attribution. England & Wales areas also carry the ONS OAC 2021 geodemographic classification (null for Scotland and Northern Ireland, which have no OAC).
-   *
-   * Codes with no persisted score are silently omitted from the result set — a request for valid-but-unscored codes returns an empty list, not a 404.
+   * Returns the Vepler Prosperity Index for one or more small areas: a composite score from 0 to 100, with the area's national decile from 1 to 10 and its national percentile. Each result carries its own `geographicCode`, breaks the score down into four weighted dimensions (income, housing, employment and living standards) and up to 19 curated indicators behind them, and adds the Office for National Statistics Output Area Classification for areas in England and Wales. Pass a single code or a comma-separated list of up to 100; codes that hold no score are left out of the response rather than reported as errors, so a request for valid but unscored codes returns an empty list.
    */
   async get(
     request: operations.GetProsperityRequest,