@vepler/sdk 6.8.0 → 6.42.0

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

@@ -3,6 +3,17 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import {
+  StreetDataset,
+  StreetDataset$outboundSchema,
+} from "./streetdataset.js";
+import { StreetField, StreetField$outboundSchema } from "./streetfield.js";
+import {
+  StreetPropertyOptions,
+  StreetPropertyOptions$Outbound,
+  StreetPropertyOptions$outboundSchema,
+} from "./streetpropertyoptions.js";
 import {
   StreetQueryByCoordinates,
   StreetQueryByCoordinates$Outbound,
@@ -39,25 +50,15 @@ export type Identifier =
   | StreetQueryByUprn
   | StreetQueryByUsrn;
 
-/**
- * How to page and filter the property list, when `includeProperties` is set.
- */
-export type PropertyOptions = {
-  /**
-   * Include retired address records alongside the current ones. Defaults to false, which returns only approved and alternative addresses.
-   */
-  includeHistoric?: boolean | undefined;
+export type StreetQueryRequest = {
   /**
-   * Maximum number of properties to return. Defaults to 100. Minimum 1, maximum 500.
+   * Which street dataset to read. 'open' reads Ordnance Survey open data published under the Open Government Licence. 'ngd' reads the Ordnance Survey National Geographic Database (NGD). 'open_then_ngd' reads the open data first and turns to the NGD only when the open data has no record or no name for the street, or when a search finds nothing in it. Postcode lookups are answered from the NGD only, so they are rejected under 'open'. Defaults to 'open_then_ngd'.
    */
-  limit?: number | undefined;
+  dataset?: StreetDataset | undefined;
   /**
-   * Number of properties to skip before the first one returned. Defaults to 0.
+   * The street fields to return. When omitted, every field the answering dataset holds is returned. Under `open_then_ngd`, a field named here that the open data lacks for a street is taken from the NGD, and `provenance` then shows which dataset supplied each field. A name is always taken whole from one dataset.
    */
-  offset?: number | undefined;
-};
-
-export type StreetQueryRequest = {
+  fields?: Array<StreetField> | undefined;
   /**
    * Which streets to return, given as one of five identifier types. Set `type` to `usrn`, `uprn`, `coordinates`, `name` or `postcode` and supply that type's own fields.
    */
@@ -68,17 +69,21 @@ export type StreetQueryRequest = {
     | StreetQueryByUprn
     | StreetQueryByUsrn;
   /**
-   * Ask for the addressable properties on each matched street. Defaults to false.
+   * Return the properties on each street under `properties`, as UPRNs. Defaults to false. Paged by `propertyOptions`.
    */
   includeProperties?: boolean | undefined;
   /**
-   * Ask for the property counts and classification breakdown for each matched street. Defaults to false.
+   * Return the number of properties on each street as `propertyCount`. Defaults to false.
    */
   includeStatistics?: boolean | undefined;
   /**
-   * How to page and filter the property list, when `includeProperties` is set.
+   * How to page and filter each street's property list. Accepted only when `includeProperties` is true.
+   */
+  propertyOptions?: StreetPropertyOptions | undefined;
+  /**
+   * Cursor for the next page: the `id` of the last street on the current page. Applies to name, coordinate and postcode lookups.
    */
-  propertyOptions?: PropertyOptions | undefined;
+  startingAfter?: string | undefined;
 };
 
 /** @internal */
@@ -106,32 +111,10 @@ export function identifierToJSON(identifier: Identifier): string {
   return JSON.stringify(Identifier$outboundSchema.parse(identifier));
 }
 
-/** @internal */
-export type PropertyOptions$Outbound = {
-  includeHistoric: boolean;
-  limit: number;
-  offset: number;
-};
-
-/** @internal */
-export const PropertyOptions$outboundSchema: z.ZodType<
-  PropertyOptions$Outbound,
-  z.ZodTypeDef,
-  PropertyOptions
-> = z.object({
-  includeHistoric: z.boolean().default(false),
-  limit: z.number().default(100),
-  offset: z.number().default(0),
-});
-
-export function propertyOptionsToJSON(
-  propertyOptions: PropertyOptions,
-): string {
-  return JSON.stringify(PropertyOptions$outboundSchema.parse(propertyOptions));
-}
-
 /** @internal */
 export type StreetQueryRequest$Outbound = {
+  dataset: string;
+  fields?: Array<string> | undefined;
   identifier:
     | StreetQueryByCoordinates$Outbound
     | StreetQueryByName$Outbound
@@ -140,7 +123,8 @@ export type StreetQueryRequest$Outbound = {
     | StreetQueryByUsrn$Outbound;
   includeProperties: boolean;
   includeStatistics: boolean;
-  propertyOptions?: PropertyOptions$Outbound | undefined;
+  propertyOptions?: StreetPropertyOptions$Outbound | undefined;
+  starting_after?: string | undefined;
 };
 
 /** @internal */
@@ -149,6 +133,8 @@ export const StreetQueryRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   StreetQueryRequest
 > = z.object({
+  dataset: StreetDataset$outboundSchema.default("open_then_ngd"),
+  fields: z.array(StreetField$outboundSchema).optional(),
   identifier: z.union([
     StreetQueryByCoordinates$outboundSchema,
     StreetQueryByName$outboundSchema,
@@ -158,7 +144,12 @@ export const StreetQueryRequest$outboundSchema: z.ZodType<
   ]),
   includeProperties: z.boolean().default(false),
   includeStatistics: z.boolean().default(false),
-  propertyOptions: z.lazy(() => PropertyOptions$outboundSchema).optional(),
+  propertyOptions: StreetPropertyOptions$outboundSchema.optional(),
+  startingAfter: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    startingAfter: "starting_after",
+  });
 });
 
 export function streetQueryRequestToJSON(

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

@@ -8,15 +8,7 @@ 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 {
-  PropertyOnStreet,
-  PropertyOnStreet$inboundSchema,
-} from "./propertyonstreet.js";
-import { StreetDetails, StreetDetails$inboundSchema } from "./streetdetails.js";
-import {
-  StreetStatistics,
-  StreetStatistics$inboundSchema,
-} from "./streetstatistics.js";
+import { StreetRecord, StreetRecord$inboundSchema } from "./streetrecord.js";
 
 /**
  * Object type discriminator. Always `list`.
@@ -32,10 +24,14 @@ export type StreetQueryResponseObject = ClosedEnum<
 >;
 
 export type StreetQueryResponse = {
+  /**
+   * The attribution that must be shown wherever the open-data street fields in this response are displayed. Present when at least one returned street carries open data.
+   */
+  attribution?: string | undefined;
   /**
    * The items on this page.
    */
-  data: Array<StreetDetails>;
+  data: Array<StreetRecord>;
   /**
    * True when further items exist beyond this page.
    */
@@ -48,14 +44,6 @@ export type StreetQueryResponse = {
    * Object type discriminator. Always `list`.
    */
   object: StreetQueryResponseObject;
-  /**
-   * The addressable properties on the matched streets. Not present in every response.
-   */
-  properties?: Array<PropertyOnStreet> | undefined;
-  /**
-   * Property counts for each matched street, keyed by USRN. Not present in every response.
-   */
-  statistics?: { [k: string]: StreetStatistics } | undefined;
   /**
    * Total number of items matching the request across all pages.
    */
@@ -77,12 +65,11 @@ export const StreetQueryResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  data: z.array(StreetDetails$inboundSchema),
+  attribution: z.string().optional(),
+  data: z.array(StreetRecord$inboundSchema),
   has_more: z.boolean(),
   message: z.string().optional(),
   object: StreetQueryResponseObject$inboundSchema,
-  properties: z.array(PropertyOnStreet$inboundSchema).optional(),
-  statistics: z.record(StreetStatistics$inboundSchema).optional(),
   total_count: z.number().optional(),
   url: z.string(),
 }).transform((v) => {

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

@@ -0,0 +1,202 @@
+/*
+ * 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 {
+  StreetDescriptor,
+  StreetDescriptor$inboundSchema,
+} from "./streetdescriptor.js";
+import {
+  StreetNameConfidence,
+  StreetNameConfidence$inboundSchema,
+} from "./streetnameconfidence.js";
+import {
+  StreetNameKind,
+  StreetNameKind$inboundSchema,
+} from "./streetnamekind.js";
+import {
+  StreetProperties,
+  StreetProperties$inboundSchema,
+} from "./streetproperties.js";
+import {
+  StreetProvenance,
+  StreetProvenance$inboundSchema,
+} from "./streetprovenance.js";
+import { StreetSource, StreetSource$inboundSchema } from "./streetsource.js";
+
+/**
+ * Representative point for the street, at its centre.
+ */
+export type StreetRecordCoordinates = {
+  /**
+   * Latitude in WGS84 decimal degrees.
+   */
+  lat: number;
+  /**
+   * Longitude in WGS84 decimal degrees.
+   */
+  lng: number;
+};
+
+/**
+ * A street, identified by its Unique Street Reference Number (USRN).
+ */
+export type StreetRecord = {
+  /**
+   * Territory the street sits in, as an ISO 3166-1 alpha-2 code.
+   */
+  country: string;
+  /**
+   * County the street falls in.
+   */
+  county?: string | null | undefined;
+  /**
+   * The dataset that supplied the street record: 'open' for Ordnance Survey open data, 'ngd' for the Ordnance Survey National Geographic Database.
+   */
+  dataset: StreetSource;
+  /**
+   * How the street is named: `name` first, then each further name the dataset records, such as the name in another language. Empty when no name is recorded or `name` was not requested.
+   */
+  descriptors: Array<StreetDescriptor>;
+  /**
+   * Distance from the query point to the street's centre in the dataset the search matched it in, in metres. Present on coordinate lookups. Under `open_then_ngd` that is the open data unless the open data has no street in the radius, so a street the NGD supplies whole because the open data holds no name for it is measured to its open data centre, and `distance` can differ from the distance to `location`.
+   */
+  distance?: number | undefined;
+  /**
+   * Local authority district the street falls in.
+   */
+  district?: string | null | undefined;
+  /**
+   * Stable identifier for the street, in the form `<country>-<scheme>:<value>`. Pass it as `starting_after` to fetch the page that follows this street.
+   */
+  id: string;
+  /**
+   * Locality the street sits in.
+   */
+  locality?: string | null | undefined;
+  /**
+   * Representative point for the street, at its centre.
+   */
+  location?: StreetRecordCoordinates | undefined;
+  /**
+   * Name of the street as the dataset that answered records it, with the dataset's own capitalisation. Names in other languages are in `descriptors`. Null when the dataset holds no name. Read `nameKind` before showing it as a street name.
+   */
+  name?: string | null | undefined;
+  /**
+   * How settled the open-data name is. 'confident' is a single name. 'ambiguous' means more than one open-data name competes for the street and `name` is one of them. 'absent' means the open data holds no name, so `name` is null.
+   */
+  nameConfidence?: StreetNameConfidence | undefined;
+  /**
+   * What `name` holds. 'name' is a street name. 'descriptor' is a description the naming authority records in place of a name, such as a road number or 'Access to ...', and is not a name the street is known by.
+   */
+  nameKind?: StreetNameKind | null | undefined;
+  /**
+   * Postcode district the street falls in, the outward part of its postcodes.
+   */
+  postcodeDistrict?: string | null | undefined;
+  /**
+   * The properties on the street, paged by `propertyOptions`.
+   */
+  properties?: StreetProperties | undefined;
+  /**
+   * Number of properties on the street. Present when `includeStatistics` is true.
+   */
+  propertyCount?: number | undefined;
+  /**
+   * Which dataset supplied each returned field. Present only when a street's fields came from more than one dataset.
+   */
+  provenance?: StreetProvenance | undefined;
+  /**
+   * Latitude where the street ends, in WGS84 decimal degrees. Present alongside `streetStartLat`.
+   */
+  streetEndLat?: number | undefined;
+  /**
+   * Longitude where the street ends, in WGS84 decimal degrees. Present alongside `streetStartLat`.
+   */
+  streetEndLng?: number | undefined;
+  /**
+   * Latitude where the street starts, in WGS84 decimal degrees. Present when the dataset that supplied the street records its start and end, which the NGD does and the open data does not.
+   */
+  streetStartLat?: number | undefined;
+  /**
+   * Longitude where the street starts, in WGS84 decimal degrees. Present alongside `streetStartLat`.
+   */
+  streetStartLng?: number | undefined;
+  /**
+   * Type of street as the naming authority records it.
+   */
+  streetType?: string | null | undefined;
+  /**
+   * Town or city the street sits in.
+   */
+  town?: string | null | undefined;
+  /**
+   * The Unique Street Reference Number (USRN).
+   */
+  usrn: number;
+};
+
+/** @internal */
+export const StreetRecordCoordinates$inboundSchema: z.ZodType<
+  StreetRecordCoordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lng: z.number(),
+});
+
+export function streetRecordCoordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<StreetRecordCoordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StreetRecordCoordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StreetRecordCoordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const StreetRecord$inboundSchema: z.ZodType<
+  StreetRecord,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  country: z.string(),
+  county: z.nullable(z.string()).optional(),
+  dataset: StreetSource$inboundSchema,
+  descriptors: z.array(StreetDescriptor$inboundSchema),
+  distance: z.number().optional(),
+  district: z.nullable(z.string()).optional(),
+  id: z.string(),
+  locality: z.nullable(z.string()).optional(),
+  location: z.lazy(() => StreetRecordCoordinates$inboundSchema).optional(),
+  name: z.nullable(z.string()).optional(),
+  nameConfidence: StreetNameConfidence$inboundSchema.optional(),
+  nameKind: z.nullable(StreetNameKind$inboundSchema).optional(),
+  postcodeDistrict: z.nullable(z.string()).optional(),
+  properties: StreetProperties$inboundSchema.optional(),
+  propertyCount: z.number().optional(),
+  provenance: StreetProvenance$inboundSchema.optional(),
+  streetEndLat: z.number().optional(),
+  streetEndLng: z.number().optional(),
+  streetStartLat: z.number().optional(),
+  streetStartLng: z.number().optional(),
+  streetType: z.nullable(z.string()).optional(),
+  town: z.nullable(z.string()).optional(),
+  usrn: z.number(),
+});
+
+export function streetRecordFromJSON(
+  jsonString: string,
+): SafeParseResult<StreetRecord, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StreetRecord$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StreetRecord' from JSON`,
+  );
+}

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

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+/**
+ * The dataset that supplied the street record: 'open' for Ordnance Survey open data, 'ngd' for the Ordnance Survey National Geographic Database.
+ */
+export const StreetSource = {
+  Open: "open",
+  Ngd: "ngd",
+} as const;
+/**
+ * The dataset that supplied the street record: 'open' for Ordnance Survey open data, 'ngd' for the Ordnance Survey National Geographic Database.
+ */
+export type StreetSource = OpenEnum<typeof StreetSource>;
+
+/** @internal */
+export const StreetSource$inboundSchema: z.ZodType<
+  StreetSource,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(StreetSource);

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

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const TitleAlertKind = {
+  LeaseTermEnded: "lease_term_ended",
+  DividedByFloor: "divided_by_floor",
+  ValueNotPrice: "value_not_price",
+  PriceCoversOtherTitles: "price_covers_other_titles",
+  LeasePremium: "lease_premium",
+  NominalPrice: "nominal_price",
+  PossessoryTitle: "possessory_title",
+  QualifiedTitle: "qualified_title",
+  GoodLeaseholdTitle: "good_leasehold_title",
+} as const;
+export type TitleAlertKind = OpenEnum<typeof TitleAlertKind>;
+
+export type TitleAlert = {
+  kind: TitleAlertKind;
+  /**
+   * Plain-English statement of the fact and why it matters.
+   */
+  message: string;
+  sourceEntryRef: string | null;
+};
+
+/** @internal */
+export const TitleAlertKind$inboundSchema: z.ZodType<
+  TitleAlertKind,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(TitleAlertKind);
+
+/** @internal */
+export const TitleAlert$inboundSchema: z.ZodType<
+  TitleAlert,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  kind: TitleAlertKind$inboundSchema,
+  message: z.string(),
+  sourceEntryRef: z.nullable(z.string()),
+});
+
+export function titleAlertFromJSON(
+  jsonString: string,
+): SafeParseResult<TitleAlert, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TitleAlert$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TitleAlert' from JSON`,
+  );
+}

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

@@ -12,6 +12,7 @@ import {
   RegisteredCharges,
   RegisteredCharges$inboundSchema,
 } from "./registeredcharges.js";
+import { TitleAlert, TitleAlert$inboundSchema } from "./titlealert.js";
 import { TitleCovenant, TitleCovenant$inboundSchema } from "./titlecovenant.js";
 import {
   TitleDocumentSummary,
@@ -70,6 +71,10 @@ export const Tenure = {
 export type Tenure = OpenEnum<typeof Tenure>;
 
 export type TitleExtractionPayload = {
+  /**
+   * Facts that no single entry states but a buyer must know: an ended lease term, a title divided by floor, a price that is a value, a premium or nominal, a class of title weaker than absolute. Empty when there are none.
+   */
+  alerts?: Array<TitleAlert> | undefined;
   /**
    * The class of title recorded in the register. `possessory` and `qualified` are material defects a lender will want to see. Null when the register does not state a class.
    */
@@ -154,6 +159,7 @@ export const TitleExtractionPayload$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  alerts: z.array(TitleAlert$inboundSchema).optional(),
   classOfTitle: z.nullable(ClassOfTitle$inboundSchema).default(null),
   covenants: z.array(TitleCovenant$inboundSchema),
   currentOwnerDisplay: z.string(),

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

@@ -4,9 +4,24 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * What the amount is. `price`: the price paid on a sale. `value`: a value stated where no price was paid (a gift, a transfer into joint names); never show it as a price. `lease_premium`: the premium paid on the grant of the lease, not a price on a later sale.
+ */
+export const Basis = {
+  Price: "price",
+  Value: "value",
+  LeasePremium: "lease_premium",
+} as const;
+/**
+ * What the amount is. `price`: the price paid on a sale. `value`: a value stated where no price was paid (a gift, a transfer into joint names); never show it as a price. `lease_premium`: the premium paid on the grant of the lease, not a price on a later sale.
+ */
+export type Basis = OpenEnum<typeof Basis>;
+
 /**
  * The price-paid entry from the Proprietorship Register. Null when the register records none.
  */
@@ -15,6 +30,10 @@ export type TitlePricePaid = {
    * The price as stated in the register, in whole pounds.
    */
   amountPounds: number;
+  /**
+   * What the amount is. `price`: the price paid on a sale. `value`: a value stated where no price was paid (a gift, a transfer into joint names); never show it as a price. `lease_premium`: the premium paid on the grant of the lease, not a price on a later sale.
+   */
+  basis: Basis;
   /**
    * The date the price is stated to have been paid on. Null when the entry states no date (a leasehold grant price, for instance).
    */
@@ -30,6 +49,10 @@ export type TitlePricePaid = {
   sourceEntryRef: string;
 };
 
+/** @internal */
+export const Basis$inboundSchema: z.ZodType<Basis, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Basis);
+
 /** @internal */
 export const TitlePricePaid$inboundSchema: z.ZodType<
   TitlePricePaid,
@@ -37,6 +60,7 @@ export const TitlePricePaid$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   amountPounds: z.number().int(),
+  basis: Basis$inboundSchema.default("price"),
   date: z.nullable(z.string()),
   rawText: z.string(),
   registrationDate: z.nullable(z.string()),

package/src/sdk/models.ts

@@ -0,0 +1,87 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { modelsGetV1AiModels } from "../funcs/modelsGetV1AiModels.js";
+import { modelsGetV1AiModelsModel } from "../funcs/modelsGetV1AiModelsModel.js";
+import {
+  modelsPostV1AiChatCompletions,
+  PostV1AiChatCompletionsAcceptEnum,
+} from "../funcs/modelsPostV1AiChatCompletions.js";
+import { modelsPostV1AiResponses } from "../funcs/modelsPostV1AiResponses.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "./models/operations/index.js";
+import * as shared from "./models/shared/index.js";
+import { unwrapAsync } from "./types/fp.js";
+
+export { PostV1AiChatCompletionsAcceptEnum } from "../funcs/modelsPostV1AiChatCompletions.js";
+
+export class Models extends ClientSDK {
+  /**
+   * List models
+   *
+   * @remarks
+   * Lists the models that can be run, each with what it reads and the JSON Schema of the result it returns. Listing models is free.
+   */
+  async getV1AiModels(
+    options?: RequestOptions,
+  ): Promise<shared.ModelList> {
+    return unwrapAsync(modelsGetV1AiModels(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve a model
+   *
+   * @remarks
+   * Returns one model, with what it reads and the JSON Schema of the result it returns. Free.
+   */
+  async getV1AiModelsModel(
+    request: operations.GetV1AiModelsModelRequest,
+    options?: RequestOptions,
+  ): Promise<shared.Model> {
+    return unwrapAsync(modelsGetV1AiModelsModel(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Run a model
+   *
+   * @remarks
+   * Runs a model on one input and returns its result as one JSON object in a standard chat completion. Send exactly one user message holding one image part. Each input is charged once, in credits, and the charge is shown in `usage`. A repeat of a completed request within 15 minutes is served from cache without charge. With `stream: true` the result arrives as server-sent events: one chunk holding the whole result, a usage chunk when `stream_options.include_usage` is true, then `[DONE]`.
+   */
+  async postV1AiChatCompletions(
+    request: shared.ChatCompletionRequest,
+    options?: RequestOptions & {
+      acceptHeaderOverride?: PostV1AiChatCompletionsAcceptEnum;
+    },
+  ): Promise<operations.PostV1AiChatCompletionsResponse> {
+    return unwrapAsync(modelsPostV1AiChatCompletions(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Run a model (Responses)
+   *
+   * @remarks
+   * Runs a model on one input and returns its result as one `output_text` holding one JSON object. Send exactly one user message holding one `input_image` part. Charged, and repeats served from cache, exactly as chat completions. Streaming is not supported on this route.
+   */
+  async postV1AiResponses(
+    request: shared.ResponseRequest,
+    options?: RequestOptions,
+  ): Promise<shared.ModelResponse> {
+    return unwrapAsync(modelsPostV1AiResponses(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -21,6 +21,7 @@ import { Heritage } from "./heritage.js";
 import { LandConstraint } from "./landconstraint.js";
 import { Listings } from "./listings.js";
 import { Metrics } from "./metrics.js";
+import { Models } from "./models.js";
 import { Planning } from "./planning.js";
 import { Poi } from "./poi.js";
 import { Property } from "./property.js";
@@ -41,6 +42,11 @@ export class SDK extends ClientSDK {
     return (this._address ??= new Address(this._options));
   }
 
+  private _models?: Models;
+  get models(): Models {
+    return (this._models ??= new Models(this._options));
+  }
+
   private _airQuality?: AirQuality;
   get airQuality(): AirQuality {
     return (this._airQuality ??= new AirQuality(this._options));