@vepler/sdk 3.0.0 → 5.28.1

package/dist/esm/sdk/transactions.d.ts

@@ -3,24 +3,24 @@ import * as operations from "./models/operations/index.js";
 import * as shared from "./models/shared/index.js";
 export declare class Transactions extends ClientSDK {
     /**
-     * Get transaction by id
+     * Get a transaction by id
      *
      * @remarks
-     * Retrieve a single transaction by its opaque composite id ({country}:{provider}:{externalId}).
+     * Returns one transaction by the composite id that search results carry. An id whose provider segment names a source that is not currently served returns a 404.
      */
     getTransactionById(request: operations.GetTransactionByIdRequest, options?: RequestOptions): Promise<shared.Transaction>;
     /**
-     * Get transactions by UPRN
+     * Get transactions for a UPRN
      *
      * @remarks
-     * Retrieve all transactions matched to a UPRN, newest first, cursor-paginated.
+     * Returns the transactions matched to one addressable location, newest first. Results are cursor-paginated, up to 100 per page.
      */
     getTransactionsByUprn(request: operations.GetTransactionsByUprnRequest, options?: RequestOptions): Promise<shared.TransactionsListResponse>;
     /**
-     * Advanced transaction search
+     * Search property transactions
      *
      * @remarks
-     * Search standardised property transactions (completed sales and lease grants) with a structured field query, geographic area filters, sorting and sparse fieldsets. Cursor-paginated. All monetary values are in minor currency units (e.g. pence for GBP).
+     * Searches completed sales and lease grants by geographic area, structured field conditions and sort order, narrowing each record to the fields named in `attributes` when one is given. Results are cursor-paginated, up to 100 per page. Monetary values are in the minor unit of their currency, so pence for GBP.
      */
     queryTransactions(request?: shared.TransactionQueryRequest | undefined, options?: RequestOptions): Promise<shared.TransactionsListResponse>;
 }

package/dist/esm/sdk/transactions.js

@@ -8,28 +8,28 @@ import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "./types/fp.js";
 export class Transactions extends ClientSDK {
     /**
-     * Get transaction by id
+     * Get a transaction by id
      *
      * @remarks
-     * Retrieve a single transaction by its opaque composite id ({country}:{provider}:{externalId}).
+     * Returns one transaction by the composite id that search results carry. An id whose provider segment names a source that is not currently served returns a 404.
      */
     async getTransactionById(request, options) {
         return unwrapAsync(transactionsGetTransactionById(this, request, options));
     }
     /**
-     * Get transactions by UPRN
+     * Get transactions for a UPRN
      *
      * @remarks
-     * Retrieve all transactions matched to a UPRN, newest first, cursor-paginated.
+     * Returns the transactions matched to one addressable location, newest first. Results are cursor-paginated, up to 100 per page.
      */
     async getTransactionsByUprn(request, options) {
         return unwrapAsync(transactionsGetTransactionsByUprn(this, request, options));
     }
     /**
-     * Advanced transaction search
+     * Search property transactions
      *
      * @remarks
-     * Search standardised property transactions (completed sales and lease grants) with a structured field query, geographic area filters, sorting and sparse fieldsets. Cursor-paginated. All monetary values are in minor currency units (e.g. pence for GBP).
+     * Searches completed sales and lease grants by geographic area, structured field conditions and sort order, narrowing each record to the fields named in `attributes` when one is given. Results are cursor-paginated, up to 100 per page. Monetary values are in the minor unit of their currency, so pence for GBP.
      */
     async queryTransactions(request, options) {
         return unwrapAsync(transactionsQueryTransactions(this, request, options));

package/dist/esm/sdk/types/discriminatedUnion.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v3";
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> = {
+    [K in Discriminator]: UnknownValue;
+} & {
+    raw: unknown;
+    isUnknown: true;
+};
+export declare function isUnknown<Discriminator extends string>(value: unknown): value is Unknown<Discriminator>;
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export declare function discriminatedUnion<InputDiscriminator extends string, TOptions extends Readonly<Record<string, z.ZodType>>, UnknownValue extends string = "UNKNOWN", OutputDiscriminator extends string = InputDiscriminator>(inputPropertyName: InputDiscriminator, options: TOptions, opts?: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+}): z.ZodType<z.output<TOptions[keyof TOptions]> | Unknown<OutputDiscriminator, UnknownValue>, z.ZodTypeDef, unknown>;
+//# sourceMappingURL=discriminatedUnion.d.ts.map

package/dist/esm/sdk/types/discriminatedUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminatedUnion.d.ts","sourceRoot":"","sources":["../../../../src/sdk/types/discriminatedUnion.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAK5B,MAAM,MAAM,OAAO,CAAC,aAAa,SAAS,MAAM,EAAE,YAAY,GAAG,SAAS,IACtE;KACC,CAAC,IAAI,aAAa,GAAG,YAAY;CACnC,GACC;IACA,GAAG,EAAE,OAAO,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEJ,wBAAgB,SAAS,CAAC,aAAa,SAAS,MAAM,EACpD,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,OAAO,CAAC,aAAa,CAAC,CAEjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,kBAAkB,SAAS,MAAM,EACjC,QAAQ,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,EACpD,YAAY,SAAS,MAAM,GAAG,SAAS,EACvC,mBAAmB,SAAS,MAAM,GAAG,kBAAkB,EAEvD,iBAAiB,EAAE,kBAAkB,EACrC,OAAO,EAAE,QAAQ,EACjB,IAAI,GAAE;IACJ,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kBAAkB,CAAC,EAAE,mBAAmB,CAAC;CACrC,GACL,CAAC,CAAC,OAAO,CACR,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,QAAQ,CAAC,CAAC,GAClC,OAAO,CAAC,mBAAmB,EAAE,YAAY,CAAC,EAC5C,CAAC,CAAC,UAAU,EACZ,OAAO,CACR,CA0CA"}

package/dist/esm/sdk/types/discriminatedUnion.js

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v3";
+import { startCountingUnrecognized } from "./unrecognized.js";
+const UNKNOWN = Symbol("UNKNOWN");
+export function isUnknown(value) {
+    return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion(inputPropertyName, options, opts = {}) {
+    const { unknownValue = "UNKNOWN", outputPropertyName } = opts;
+    return z.unknown().transform((input) => {
+        const fallback = Object.defineProperties({
+            raw: input,
+            [outputPropertyName ?? inputPropertyName]: unknownValue,
+            isUnknown: true,
+        }, { [UNKNOWN]: { value: true, enumerable: false, configurable: false } });
+        const isObject = typeof input === "object" && input !== null;
+        if (!isObject)
+            return fallback;
+        const discriminator = input[inputPropertyName];
+        if (typeof discriminator !== "string")
+            return fallback;
+        if (!(discriminator in options))
+            return fallback;
+        const schema = options[discriminator];
+        if (!schema)
+            return fallback;
+        // Start counters before parsing to track nested unrecognized/zeroDefault values
+        const unrecognizedCtr = startCountingUnrecognized();
+        const result = schema.safeParse(input);
+        if (!result.success) {
+            // Parse failed - don't propagate any counts from the failed attempt
+            unrecognizedCtr.end(0);
+            return fallback;
+        }
+        // Parse succeeded - propagate the actual counts
+        unrecognizedCtr.end();
+        if (outputPropertyName) {
+            result.data[outputPropertyName] = discriminator;
+        }
+        return result.data;
+    });
+}
+//# sourceMappingURL=discriminatedUnion.js.map

package/dist/esm/sdk/types/discriminatedUnion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminatedUnion.js","sourceRoot":"","sources":["../../../../src/sdk/types/discriminatedUnion.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAWlC,MAAM,UAAU,SAAS,CACvB,KAAc;IAEd,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,CAAC;AACzE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAMhC,iBAAqC,EACrC,OAAiB,EACjB,OAGI,EAAE;IAON,MAAM,EAAE,YAAY,GAAG,SAAyB,EAAE,kBAAkB,EAAE,GAAG,IAAI,CAAC;IAC9E,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;QACrC,MAAM,QAAQ,GAAG,MAAM,CAAC,gBAAgB,CACtC;YACE,GAAG,EAAE,KAAK;YACV,CAAC,kBAAkB,IAAI,iBAAiB,CAAC,EAAE,YAAY;YACvD,SAAS,EAAE,IAAa;SACzB,EACD,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,CACvE,CAAC;QAEF,MAAM,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;QAC7D,IAAI,CAAC,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAE/B,MAAM,aAAa,GAAG,KAAK,CAAC,iBAAuC,CAAC,CAAC;QACrE,IAAI,OAAO,aAAa,KAAK,QAAQ;YAAE,OAAO,QAAQ,CAAC;QACvD,IAAI,CAAC,CAAC,aAAa,IAAI,OAAO,CAAC;YAAE,OAAO,QAAQ,CAAC;QAEjD,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM;YAAE,OAAO,QAAQ,CAAC;QAE7B,gFAAgF;QAChF,MAAM,eAAe,GAAG,yBAAyB,EAAE,CAAC;QAEpD,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,oEAAoE;YACpE,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAEvB,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,gDAAgD;QAChD,eAAe,CAAC,GAAG,EAAE,CAAC;QAEtB,IAAI,kBAAkB,EAAE,CAAC;YACtB,MAAM,CAAC,IAAY,CAAC,kBAAkB,CAAC,GAAG,aAAa,CAAC;QAC3D,CAAC;QAED,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC,CAAQ,CAAC;AACZ,CAAC"}

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@vepler/sdk",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "exports": {
     ".": "./src/index.ts",    
     "./sdk/models/errors": "./src/sdk/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vepler/sdk",
-  "version": "3.0.0",
+  "version": "5.28.1",
   "author": "Vepler Limited",
   "type": "module",
   "tshy": {

package/src/address-search/default-transports.ts

@@ -172,9 +172,10 @@ export type UprnLookupFn = (
 /**
  * Default retrieve transport: resolves a selected suggestion to the full
  * address record through the SDK's UPRN lookup (`GET /v1/address/uprn/{uprn}`).
- * Swap it out once the dedicated candidate-set retrieve endpoint ships — the
- * `searchId` on the request is there for exactly that transport; this one
- * cannot attribute it, so the lookup opens its own transaction row server-side.
+ * This IS the canonical selection path (SV2-F4 removed the interim retrieve
+ * endpoint): the session settles independently via the sweep, so the lookup
+ * deliberately opens its own transaction row server-side; the `searchId` on
+ * the request stays available to custom transports that want to correlate.
  */
 export function createUprnRetrieveTransport(
   client: SDKCore,

package/src/funcs/addressBulkLookupPostcodes.ts

@@ -27,10 +27,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Batch postcode lookup
+ * Look up many postcodes at once
  *
  * @remarks
- * Look up addresses for up to 100 postcodes in a single request. Results are returned keyed by formatted postcode.
+ * Looks up addresses for up to 100 postcodes in one request. Results come back keyed by formatted postcode, each carrying its own status, so a postcode that cannot be resolved does not fail the rest of the batch.
  */
 export function addressBulkLookupPostcodes(
   client: SDKCore,

package/src/funcs/addressChangelogList.ts

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SDKCore } from "../core.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../sdk/models/errors/httpclienterrors.js";
+import * as errors from "../sdk/models/errors/index.js";
+import { ResponseValidationError } from "../sdk/models/errors/responsevalidationerror.js";
+import { SDKBaseError } from "../sdk/models/errors/sdkbaseerror.js";
+import { SDKValidationError } from "../sdk/models/errors/sdkvalidationerror.js";
+import * as shared from "../sdk/models/shared/index.js";
+import { APICall, APIPromise } from "../sdk/types/async.js";
+import { Result } from "../sdk/types/fp.js";
+
+/**
+ * List Address API changelog entries
+ *
+ * @remarks
+ * An append-only record of every shape change to the Address API, so an integration can watch for changes instead of discovering them. Each entry carries a dated `objectVersion`, the kind of change (`additive`, `deprecation`, `removal` or `fix`), the shapes or endpoints it affects, and, for a deprecation, the sunset date that matches the `Sunset` header on the endpoint being retired. Responses are cached for an hour, so this is cheap to poll.
+ */
+export function addressChangelogList(
+  client: SDKCore,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    shared.ChangelogListResponse,
+    | errors.ListAddressChangelogResponseBody
+    | SDKBaseError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    options,
+  ));
+}
+
+async function $do(
+  client: SDKCore,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      shared.ChangelogListResponse,
+      | errors.ListAddressChangelogResponseBody
+      | SDKBaseError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const path = pathToFunc("/v1/address/changelog")();
+
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listAddressChangelog",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    shared.ChangelogListResponse,
+    | errors.ListAddressChangelogResponseBody
+    | SDKBaseError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, shared.ChangelogListResponse$inboundSchema),
+    M.jsonErr(500, errors.ListAddressChangelogResponseBody$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/addressCleanseAddresses.ts

@@ -27,10 +27,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Batch address cleansing and verification
+ * Cleanse and verify addresses in bulk
  *
  * @remarks
- * Verifies and cleanses up to 25 raw address strings against the national address database. Returns match status, confidence scores, and corrected fields.
+ * Matches up to 25 raw address strings against the national address register and returns the cleansed address for each, with a confidence score, a quality grade and the fields that changed. Use it to tidy an existing address list before loading it.
  */
 export function addressCleanseAddresses(
   client: SDKCore,

package/src/funcs/addressGetNearestPostcodes.ts

@@ -31,7 +31,7 @@ import { Result } from "../sdk/types/fp.js";
  * Find nearest postcodes
  *
  * @remarks
- * Returns postcodes near the specified postcode, sorted by distance.
+ * Returns the postcodes closest to a given postcode's centroid, nearest first, with the distance to each in metres.
  */
 export function addressGetNearestPostcodes(
   client: SDKCore,

package/src/funcs/addressLookupOutcode.ts

@@ -28,10 +28,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Look up outcode area
+ * Look up an outward code
  *
  * @remarks
- * Returns metadata for an outward code (e.g. SW1A, E1, M1) including centroid, country, region, and postcode count.
+ * Returns what is known about an outward code, the first part of a postcode such as `SW1A`, `E1` or `M1`: a representative point, the country, region and local authority it sits in, and how many postcodes it holds. Add `include=postcodes` for the postcodes themselves.
  */
 export function addressLookupOutcode(
   client: SDKCore,

package/src/funcs/addressLookupPostcode.ts

@@ -31,7 +31,7 @@ import { Result } from "../sdk/types/fp.js";
  * Look up addresses by postcode
  *
  * @remarks
- * Returns all addresses at a given UK postcode, sorted by house number. Supports pagination and optional geographic context enrichment.
+ * Returns every address at a UK postcode, ordered by house number. Page through them with `limit` and `offset`, and add the administrative and statistical geography for the postcode with `include=geography`.
  */
 export function addressLookupPostcode(
   client: SDKCore,

package/src/funcs/addressLookupUprn.ts

@@ -28,10 +28,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Look up address by UPRN
+ * Look up an address by UPRN
  *
  * @remarks
- * Returns a single address by its Unique Property Reference Number (UPRN).
+ * Returns the single address held for a Unique Property Reference Number, with its postal form alongside when the UPRN has a Royal Mail delivery point. Add `include=geography` for the administrative and statistical areas the address falls in.
  */
 export function addressLookupUprn(
   client: SDKCore,

package/src/funcs/addressResolveAddress.ts

@@ -28,12 +28,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Resolve addresses to UPRNs with AI
+ * Resolve an address to UPRNs
  *
  * @remarks
- * AI-powered address resolution that converts address strings to UPRNs (Unique Property Reference Numbers). Uses advanced LLM parsing to handle complex multi-unit addresses, ranges, incomplete addresses, and various formatting styles. Combines Elasticsearch search with intelligent postcode-based fallback for maximum accuracy.
- *
- * By default, only residential addresses are matched. Pass `classification: 'commercial'` to match commercial premises, or `classification: 'all'` to match all address types.
+ * Resolves a free-text address to one or more Unique Property Reference Numbers, each with a confidence score and a recommended action. It copes with multi-unit addresses, house-number ranges, incomplete addresses and inconsistent formatting, and falls back to postcode-level matching when the primary match is weak or absent. Only residential addresses are matched by default; pass `classification: 'commercial'` for commercial premises or `classification: 'all'` for every address type.
  */
 export function addressResolveAddress(
   client: SDKCore,

package/src/funcs/addressReverseGeocode.ts

@@ -28,10 +28,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Reverse geocode (coordinates to addresses)
+ * Find addresses near a coordinate
  *
  * @remarks
- * Returns addresses near the specified coordinates, sorted by distance.
+ * Returns the addresses closest to a coordinate, nearest first, with the distance to each in metres. Both `lat` and `lng` are required.
  */
 export function addressReverseGeocode(
   client: SDKCore,

package/src/funcs/addressValidatePostcode.ts

@@ -31,7 +31,7 @@ import { Result } from "../sdk/types/fp.js";
  * Validate a UK postcode
  *
  * @remarks
- * Validates whether a UK postcode exists and is active. Always returns 200 — the `valid` field indicates the result. Includes centroid coordinates and area codes when valid.
+ * Checks whether a UK postcode exists and is in use. The answer is always a 200 response: read the `valid` field for it. A valid postcode also returns its centroid and its statistical area codes.
  */
 export function addressValidatePostcode(
   client: SDKCore,

package/src/funcs/airQualityPoint.ts

@@ -27,14 +27,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Coordinate-exact air quality with property-decay overlay
+ * Get air quality at an exact coordinate
  *
  * @remarks
- * Returns property-exact air-quality data for a single (lat, lon) coordinate. Reads the 1km cell substrate, then overlays exact distances to nearest road, nearest motorway, nearby installations, and regulatory zones. A versioned decay model (Karner-2010 exponential, AURN-calibrated) adjusts pollutant concentrations from the cell-level PCM background to the property point.
- *
- * Use `/point` for property-level decisions (valuation, mortgage, insurance). Use `/query` for bulk neighbourhood-scale lookups (bbox, postcode, outcode). Both return the same envelope shape; `/point` adds `coordinate`, `cellId`, and `decay` blocks.
- *
- * Premium attributes (`nearestRoad`, `nearestMotorway`, `installations`) and the explain-mode calculation trail (`decay.calculation`) require the `air-quality:premium` permission.
+ * Returns air quality at one latitude and longitude. It reads the 1 km cell the point falls in, then measures the exact distances to the nearest road, the nearest motorway, nearby regulated installations and the regulatory zones, and applies a versioned decay model so the pollutant concentrations reflect the point rather than the whole cell. Reach for this route for decisions about a single property, and for `/v1/air-quality/query` for neighbourhood-scale lookups. The response is the same shape as that route's, plus `coordinate`, `cellId` and `decay`. `nearestRoad`, `nearestMotorway`, `installations` and the calculation trail in `decay.calculation` are returned only on licences carrying the `airQualityPremium` permission.
  */
 export function airQualityPoint(
   client: SDKCore,

package/src/funcs/airQualityQuery.ts

@@ -30,9 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Query air quality at one or more locations
  *
  * @remarks
- * Retrieve air-quality data for one or more geographic areas. Supports nearest-cell lookup (single point with radius 0), radius search, postcode lookup, outcode lookup, bounding-box and polygon area filters. Multiple areas can be combined in a single request — up to 10 areas, results are OR-combined and deduplicated by `airQualityId`.
- *
- * Each response cell carries the air-quality summary (platform 0-100 score, band, dominant source), per-pollutant concentrations with framework-tagged compliance checks (UK AQS 2010, WHO AQG 2021), official indices (DAQI), regulator-defined zone memberships (AQMA, CAZ, ULEZ, LEZ, smoke control), and provenance. Premium attributes (`nearestRoad`, `nearestMotorway`, `installations`) require the `air-quality:premium` permission.
+ * Returns air quality for one or more areas, given as a point (with a radius, or radius 0 for the nearest 1 km cell only), a postcode, an outward code, a bounding box or a polygon. Up to ten areas can be combined in one request, and their results are deduplicated by `airQualityId`. Every cell carries the score and band, the pollutant concentrations with their compliance against each standard, the published indices, the regulator-defined zones containing it, and provenance. `nearestRoad`, `nearestMotorway` and `installations` are returned only on licences carrying the `airQualityPremium` permission. For a single property, use `/v1/air-quality/point` instead.
  */
 export function airQualityQuery(
   client: SDKCore,

package/src/funcs/areasGetAreas.ts

@@ -27,10 +27,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Get geographic areas by field and IDs
+ * Get geographic areas by code
  *
  * @remarks
- * Retrieve geographic areas by field type (postcode, ward, county, etc.) and comma-separated IDs. Optionally include geometry, relationships, and hierarchy data.
+ * Looks up areas by geography type and a comma-separated list of codes, and returns each one with its name, centre point and any geometry, relationships or hierarchy that was asked for. At most 100 codes can be given in a single request.
  */
 export function areasGetAreas(
   client: SDKCore,

package/src/funcs/areasGetAreasWithin.ts

@@ -30,7 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Find areas within a radius of a location
  *
  * @remarks
- * Find geographic areas within a specified radius of a latitude/longitude point. Filter by area type and optionally include geometry data.
+ * Returns the areas that fall within a radius of a point, each with its distance from that point. Narrow the search to a single geography type with `type`, and ask for boundaries with `includeGeometry`.
  */
 export function areasGetAreasWithin(
   client: SDKCore,

package/src/funcs/areasGetBorderingAreas.ts

@@ -30,7 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Find areas that border a target area
  *
  * @remarks
- * Find all areas of a specified type that share a border with the target area.
+ * Returns every area of the requested type whose boundary touches the target area, for example the districts that border a given district.
  */
 export function areasGetBorderingAreas(
   client: SDKCore,

package/src/funcs/areasGetChildAreas.ts

@@ -27,10 +27,10 @@ import { APICall, APIPromise } from "../sdk/types/async.js";
 import { Result } from "../sdk/types/fp.js";
 
 /**
- * Get child areas within a parent area
+ * Get the areas inside a parent area
  *
  * @remarks
- * Retrieve all child areas contained within a parent geographic area. Optionally filter by child type using the childType query parameter.
+ * Returns the areas contained by a parent area, such as the wards inside a local authority district. Narrow the result to one geography type with `childType`.
  */
 export function areasGetChildAreas(
   client: SDKCore,

package/src/funcs/areasGetCoverage.ts

@@ -30,13 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Calculate geographic coverage
  *
  * @remarks
- * Calculate spatial coverage for a geographic area. Supports two modes:
- *
- * 1. **Geography-to-geography**: Use `sourceCode` + `targetCode` to calculate the overlap between two geographic areas.
- *
- * 2. **Environmental coverage**: Use `sourceCode` + `coverageType` to calculate coverage of an environmental layer (flood risk, noise, radon, conservation areas, etc.) within the source geography.
- *
- * Optionally use `intersectsWith` with environmental coverage to find entities (buildings, parcels) affected by the environmental layer.
+ * Measures how much of one geography something else covers. Give `sourceCode` with `targetCode` to measure the overlap between two geographies, or with `coverageType` to measure a layer such as flood risk, noise, radon or a conservation designation within the source area. Add `intersectsWith` to count the buildings or land parcels the layer touches instead of measuring area. Exactly one of `targetCode` and `coverageType` must be supplied.
  */
 export function areasGetCoverage(
   client: SDKCore,

package/src/funcs/avmGetValuationAnalysis.ts

@@ -30,7 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Get detailed valuation analysis
  *
  * @remarks
- * Get comprehensive valuation analysis for a property including comparable properties, market statistics, confidence metrics, and historical valuations. This endpoint provides detailed insights for property valuation decision-making.
+ * Value a property and return the evidence behind the figure: every comparable property with the tier it was placed in, market statistics across those comparables, a confidence breakdown, and up to 24 months of past valuations. Reach for this when the estimate on its own is not enough and the workings matter.
  */
 export function avmGetValuationAnalysis(
   client: SDKCore,

package/src/funcs/avmPredictPropertyValue.ts

@@ -30,7 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Predict property value
  *
  * @remarks
- * Get an automated valuation for a property based on its characteristics and location. Receive accurate property valuations with confidence intervals powered by advanced machine learning.
+ * Estimate what a property is worth from its characteristics and location. Supply either a postcode or a latitude and longitude pair. The response carries the estimate, the bounds either side of it and, when `ratePrice` is set alongside an `inputPrice`, a rating of that price against the estimate.
  */
 export function avmPredictPropertyValue(
   client: SDKCore,

package/src/funcs/avmPredictPropertyValueByLocation.ts

@@ -30,7 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Predict property value by location ID
  *
  * @remarks
- * Get an automated valuation for a property using its location ID. We'll retrieve the property details and generate an accurate valuation with confidence intervals. You can optionally override any property characteristics to see how they affect the valuation.
+ * Estimate what a property is worth from its location ID. The details held for that location are fetched and valued, so no characteristics need to be supplied. Any characteristic sent on the request replaces the stored value, which is how to test what a different bedroom count or floor area does to the estimate.
  */
 export function avmPredictPropertyValueByLocation(
   client: SDKCore,

package/src/funcs/buildingsAggregate.ts

@@ -30,9 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Aggregate buildings
  *
  * @remarks
- * Run aggregations (analytics) on the buildings index with optional filters, advanced query, and area scope.
- *
- * Supports terms, stats, min/max/avg/sum, cardinality, histogram, date_histogram, percentiles, and geotile_grid. Up to 10 aggregations per request. The response `aggregations` object is keyed by the `name` you provide in each aggregation definition.
+ * Summarise buildings in bulk rather than listing them: counts by use, height and footprint statistics, distributions over time, and map-tile groupings. The same filters and geographic areas as the search endpoint decide which buildings are counted. A request may carry up to 10 aggregations, and results come back keyed by the `name` given in each definition, so pick names that are unique within the request.
  */
 export function buildingsAggregate(
   client: SDKCore,