@vepler/sdk 6.1.0 → 6.36.0

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

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 { Model, Model$inboundSchema } from "./model.js";
+
+export const ModelListObject = {
+  List: "list",
+} as const;
+export type ModelListObject = ClosedEnum<typeof ModelListObject>;
+
+export type ModelList = {
+  data: Array<Model>;
+  object: ModelListObject;
+};
+
+/** @internal */
+export const ModelListObject$inboundSchema: z.ZodNativeEnum<
+  typeof ModelListObject
+> = z.nativeEnum(ModelListObject);
+
+/** @internal */
+export const ModelList$inboundSchema: z.ZodType<
+  ModelList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(Model$inboundSchema),
+  object: ModelListObject$inboundSchema,
+});
+
+export function modelListFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelList' from JSON`,
+  );
+}

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

@@ -0,0 +1,242 @@
+/*
+ * 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";
+
+export const ModelResponseObject = {
+  Response: "response",
+} as const;
+export type ModelResponseObject = ClosedEnum<typeof ModelResponseObject>;
+
+export const ModelResponseSchemasType = {
+  OutputText: "output_text",
+} as const;
+export type ModelResponseSchemasType = ClosedEnum<
+  typeof ModelResponseSchemasType
+>;
+
+export type Content = {
+  /**
+   * Always empty.
+   */
+  annotations: Array<any>;
+  /**
+   * The result: one JSON object, as a string, matching the model's output schema.
+   */
+  text: string;
+  type: ModelResponseSchemasType;
+};
+
+export const ModelResponseRole = {
+  Assistant: "assistant",
+} as const;
+export type ModelResponseRole = ClosedEnum<typeof ModelResponseRole>;
+
+export const ModelResponseSchemasStatus = {
+  Completed: "completed",
+} as const;
+export type ModelResponseSchemasStatus = ClosedEnum<
+  typeof ModelResponseSchemasStatus
+>;
+
+export const ModelResponseType = {
+  Message: "message",
+} as const;
+export type ModelResponseType = ClosedEnum<typeof ModelResponseType>;
+
+export type Output = {
+  content: Array<Content>;
+  id: string;
+  role: ModelResponseRole;
+  status: ModelResponseSchemasStatus;
+  type: ModelResponseType;
+};
+
+export const ModelResponseStatus = {
+  Completed: "completed",
+} as const;
+export type ModelResponseStatus = ClosedEnum<typeof ModelResponseStatus>;
+
+export type ModelResponseUsage = {
+  /**
+   * Tokens the model read as input, including the model's fixed instructions.
+   */
+  inputTokens: number;
+  /**
+   * Tokens the model produced.
+   */
+  outputTokens: number;
+  /**
+   * Sum of input and output tokens.
+   */
+  totalTokens: number;
+  /**
+   * Credits charged for this request. Zero when the result is a repeat served without charge.
+   */
+  veplerCredits: number;
+  /**
+   * Inputs charged for by this request. Zero when the result is a repeat served without charge.
+   */
+  veplerUnits: number;
+};
+
+export type ModelResponse = {
+  /**
+   * Unix time in seconds when the result was produced.
+   */
+  createdAt: number;
+  error?: any | null | undefined;
+  /**
+   * Identifier of this response.
+   */
+  id: string;
+  incompleteDetails?: any | null | undefined;
+  /**
+   * Id of the model that ran.
+   */
+  model: string;
+  object: ModelResponseObject;
+  /**
+   * Exactly one message holding one `output_text` part.
+   */
+  output: Array<Output>;
+  status: ModelResponseStatus;
+  usage: ModelResponseUsage;
+};
+
+/** @internal */
+export const ModelResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof ModelResponseObject
+> = z.nativeEnum(ModelResponseObject);
+
+/** @internal */
+export const ModelResponseSchemasType$inboundSchema: z.ZodNativeEnum<
+  typeof ModelResponseSchemasType
+> = z.nativeEnum(ModelResponseSchemasType);
+
+/** @internal */
+export const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown> =
+  z.object({
+    annotations: z.array(z.any()),
+    text: z.string(),
+    type: ModelResponseSchemasType$inboundSchema,
+  });
+
+export function contentFromJSON(
+  jsonString: string,
+): SafeParseResult<Content, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Content$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Content' from JSON`,
+  );
+}
+
+/** @internal */
+export const ModelResponseRole$inboundSchema: z.ZodNativeEnum<
+  typeof ModelResponseRole
+> = z.nativeEnum(ModelResponseRole);
+
+/** @internal */
+export const ModelResponseSchemasStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ModelResponseSchemasStatus
+> = z.nativeEnum(ModelResponseSchemasStatus);
+
+/** @internal */
+export const ModelResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof ModelResponseType
+> = z.nativeEnum(ModelResponseType);
+
+/** @internal */
+export const Output$inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown> = z
+  .object({
+    content: z.array(z.lazy(() => Content$inboundSchema)),
+    id: z.string(),
+    role: ModelResponseRole$inboundSchema,
+    status: ModelResponseSchemasStatus$inboundSchema,
+    type: ModelResponseType$inboundSchema,
+  });
+
+export function outputFromJSON(
+  jsonString: string,
+): SafeParseResult<Output, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Output$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Output' from JSON`,
+  );
+}
+
+/** @internal */
+export const ModelResponseStatus$inboundSchema: z.ZodNativeEnum<
+  typeof ModelResponseStatus
+> = z.nativeEnum(ModelResponseStatus);
+
+/** @internal */
+export const ModelResponseUsage$inboundSchema: z.ZodType<
+  ModelResponseUsage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input_tokens: z.number().int(),
+  output_tokens: z.number().int(),
+  total_tokens: z.number().int(),
+  vepler_credits: z.number().int(),
+  vepler_units: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "input_tokens": "inputTokens",
+    "output_tokens": "outputTokens",
+    "total_tokens": "totalTokens",
+    "vepler_credits": "veplerCredits",
+    "vepler_units": "veplerUnits",
+  });
+});
+
+export function modelResponseUsageFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelResponseUsage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelResponseUsage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelResponseUsage' from JSON`,
+  );
+}
+
+/** @internal */
+export const ModelResponse$inboundSchema: z.ZodType<
+  ModelResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created_at: z.number().int(),
+  error: z.nullable(z.any()).optional(),
+  id: z.string(),
+  incomplete_details: z.nullable(z.any()).optional(),
+  model: z.string(),
+  object: ModelResponseObject$inboundSchema,
+  output: z.array(z.lazy(() => Output$inboundSchema)),
+  status: ModelResponseStatus$inboundSchema,
+  usage: z.lazy(() => ModelResponseUsage$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "incomplete_details": "incompleteDetails",
+  });
+});
+
+export function modelResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelResponse' from JSON`,
+  );
+}

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

@@ -20,6 +20,10 @@ export const MortgageChargeStatus = {
 export type MortgageChargeStatus = OpenEnum<typeof MortgageChargeStatus>;
 
 export type MortgageCharge = {
+  /**
+   * Other title numbers the same charge is registered against, read from an `affecting also title …` clause. Empty when the charge affects only `titleAffected`.
+   */
+  alsoAffectsTitles: Array<string>;
   chargeDate: string;
   chargeHolder: TitleProprietor;
   /**
@@ -55,6 +59,7 @@ export const MortgageCharge$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  alsoAffectsTitles: z.array(z.string()),
   chargeDate: z.string(),
   chargeHolder: TitleProprietor$inboundSchema,
   dischargedDate: z.nullable(z.string()),

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

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ObservedFeature = {
+  /**
+   * Confidence of the strongest supporting image, from 0 to 1.
+   */
+  confidence?: number | undefined;
+  /**
+   * How many photographs support the feature. This counts images, not rooms: three photographs of a bathroom do not mean three bathrooms.
+   */
+  imageCount?: number | undefined;
+  /**
+   * Whether the photographs support this feature at the published confidence.
+   */
+  present?: boolean | undefined;
+};
+
+/** @internal */
+export const ObservedFeature$inboundSchema: z.ZodType<
+  ObservedFeature,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number().optional(),
+  imageCount: z.number().int().optional(),
+  present: z.boolean().optional(),
+});
+
+export function observedFeatureFromJSON(
+  jsonString: string,
+): SafeParseResult<ObservedFeature, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ObservedFeature$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ObservedFeature' from JSON`,
+  );
+}

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

@@ -12,13 +12,20 @@ export type OtherCharge = {
    * The kind of charge, as the register labels it.
    */
   chargeType: string;
+  /**
+   * The date the entry was made in the register (the entry's `(dd.mm.yyyy)` prefix). Null when the entry carries no registration date.
+   */
   date: string | null;
   /**
    * Plain-English explanation of what this charge means for the owner, written by a language model from the register entry.
    */
   effectOfCharge: string;
   /**
-   * The parties named in the original charge entry.
+   * The date of the deed the entry refers to (the conveyance, transfer, lease or charge that created it), when the entry states one. Null otherwise. Distinct from `date`, which is when the entry was registered.
+   */
+  instrumentDate: string | null;
+  /**
+   * The parties the entry names, verbatim, in the order the deed lists them. Empty when the entry names nobody. Never a placeholder: an entry that names parties and reports none here is an extraction defect, not a register fact.
    */
   originalParties: Array<string>;
   sourceEntryRef: string;
@@ -33,6 +40,7 @@ export const OtherCharge$inboundSchema: z.ZodType<
   chargeType: z.string(),
   date: z.nullable(z.string()),
   effectOfCharge: z.string(),
+  instrumentDate: z.nullable(z.string()),
   originalParties: z.array(z.string()),
   sourceEntryRef: z.string(),
 });

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

@@ -16,14 +16,16 @@ import {
 /**
  * How the scheme charges. Under 'daily' a non-compliant vehicle pays a charge for each day it enters, as in the English clean air zones, the London ULEZ and LEZ, and the Oxford ZEZ. Under 'penalty' there is nothing to pay in advance and a non-compliant entry is fined, as in the Scottish low emission zones.
  */
-export const Model = {
+export const RegulatoryZoneChargesModel = {
   Daily: "daily",
   Penalty: "penalty",
 } as const;
 /**
  * How the scheme charges. Under 'daily' a non-compliant vehicle pays a charge for each day it enters, as in the English clean air zones, the London ULEZ and LEZ, and the Oxford ZEZ. Under 'penalty' there is nothing to pay in advance and a non-compliant entry is fined, as in the Scottish low emission zones.
  */
-export type Model = OpenEnum<typeof Model>;
+export type RegulatoryZoneChargesModel = OpenEnum<
+  typeof RegulatoryZoneChargesModel
+>;
 
 /**
  * What it costs to enter the zone in a non-compliant vehicle. Present only for schemes that levy something, such as clean air zones, the ULEZ, low emission zones, zero emission zones and their international equivalents. Absent for designations that carry no charge, such as air quality management areas and flood zones.
@@ -36,7 +38,7 @@ export type RegulatoryZoneCharges = {
   /**
    * How the scheme charges. Under 'daily' a non-compliant vehicle pays a charge for each day it enters, as in the English clean air zones, the London ULEZ and LEZ, and the Oxford ZEZ. Under 'penalty' there is nothing to pay in advance and a non-compliant entry is fined, as in the Scottish low emission zones.
    */
-  model: Model;
+  model: RegulatoryZoneChargesModel;
   /**
    * One line per vehicle class the schedule covers.
    */
@@ -52,8 +54,11 @@ export type RegulatoryZoneCharges = {
 };
 
 /** @internal */
-export const Model$inboundSchema: z.ZodType<Model, z.ZodTypeDef, unknown> =
-  openEnums.inboundSchema(Model);
+export const RegulatoryZoneChargesModel$inboundSchema: z.ZodType<
+  RegulatoryZoneChargesModel,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RegulatoryZoneChargesModel);
 
 /** @internal */
 export const RegulatoryZoneCharges$inboundSchema: z.ZodType<
@@ -62,7 +67,7 @@ export const RegulatoryZoneCharges$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   asOf: z.nullable(z.string()).optional(),
-  model: Model$inboundSchema,
+  model: RegulatoryZoneChargesModel$inboundSchema,
   rates: z.array(RegulatoryZoneChargeRate$inboundSchema),
   source: z.nullable(z.string()).optional(),
   year: z.number().int(),

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

@@ -0,0 +1,220 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+
+/**
+ * Exactly one message with role `user`, whose content is one `input_image` part: an `https` URL on a public host name, or a base64 `data:` URL with a raster image type. The image can be up to 20 MiB. Text input is refused because the model's instructions are fixed.
+ */
+export type Input = string | Array<{ [k: string]: any }>;
+
+/**
+ * Output format: `json_object`, or `json_schema` with `name` set to the model's `output_schema_name` and `schema` either omitted or equal to its `output_schema`. The result is the same JSON object either way.
+ */
+export type Format = {
+  type: string;
+  additionalProperties?: { [k: string]: any } | undefined;
+};
+
+/**
+ * Output format, under `format`, with the same rules as `response_format` on chat completions.
+ */
+export type Text = {
+  /**
+   * Output format: `json_object`, or `json_schema` with `name` set to the model's `output_schema_name` and `schema` either omitted or equal to its `output_schema`. The result is the same JSON object either way.
+   */
+  format?: Format | undefined;
+  additionalProperties?: { [k: string]: any } | undefined;
+};
+
+export type ResponseRequest = {
+  /**
+   * Exactly one message with role `user`, whose content is one `input_image` part: an `https` URL on a public host name, or a base64 `data:` URL with a raster image type. The image can be up to 20 MiB. Text input is refused because the model's instructions are fixed.
+   */
+  input: string | Array<{ [k: string]: any }>;
+  /**
+   * Not supported. Any non-empty value is refused.
+   */
+  instructions?: string | null | undefined;
+  /**
+   * Accepted and ignored. Each model has a fixed output limit.
+   */
+  maxOutputTokens?: number | null | undefined;
+  /**
+   * Accepted and ignored.
+   */
+  metadata?: { [k: string]: string } | null | undefined;
+  /**
+   * Id of the model to run, from `GET /models`.
+   */
+  model: string;
+  /**
+   * Accepted and ignored.
+   */
+  parallelToolCalls?: boolean | null | undefined;
+  /**
+   * Accepted and ignored.
+   */
+  serviceTier?: string | null | undefined;
+  /**
+   * Accepted and ignored. A completed result is kept for 15 minutes, only to answer an identical repeat from the same account without a charge.
+   */
+  store?: boolean | null | undefined;
+  /**
+   * Not supported on this route. Use chat completions to stream.
+   */
+  stream?: boolean | null | undefined;
+  /**
+   * Accepted and ignored. The model always runs at temperature 0.
+   */
+  temperature?: number | null | undefined;
+  /**
+   * Output format, under `format`, with the same rules as `response_format` on chat completions.
+   */
+  text?: Text | null | undefined;
+  /**
+   * Not supported. Any value other than `none` is refused.
+   */
+  toolChoice?: any | undefined;
+  /**
+   * Not supported. A non-empty list is refused.
+   */
+  tools?: Array<any> | null | undefined;
+  /**
+   * Accepted and ignored.
+   */
+  topP?: number | null | undefined;
+  /**
+   * Accepted and ignored.
+   */
+  truncation?: string | null | undefined;
+  /**
+   * Accepted and ignored.
+   */
+  user?: string | null | undefined;
+};
+
+/** @internal */
+export type Input$Outbound = string | Array<{ [k: string]: any }>;
+
+/** @internal */
+export const Input$outboundSchema: z.ZodType<
+  Input$Outbound,
+  z.ZodTypeDef,
+  Input
+> = z.union([z.string(), z.array(z.record(z.any()))]);
+
+export function inputToJSON(input: Input): string {
+  return JSON.stringify(Input$outboundSchema.parse(input));
+}
+
+/** @internal */
+export type Format$Outbound = {
+  type: string;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const Format$outboundSchema: z.ZodType<
+  Format$Outbound,
+  z.ZodTypeDef,
+  Format
+> = z.object({
+  additionalProperties: z.record(z.any()).optional(),
+  type: z.string(),
+}).transform((v) => {
+  return {
+    ...v.additionalProperties,
+    ...remap$(v, {
+      additionalProperties: null,
+    }),
+  };
+});
+
+export function formatToJSON(format: Format): string {
+  return JSON.stringify(Format$outboundSchema.parse(format));
+}
+
+/** @internal */
+export type Text$Outbound = {
+  format?: Format$Outbound | undefined;
+  [additionalProperties: string]: unknown;
+};
+
+/** @internal */
+export const Text$outboundSchema: z.ZodType<Text$Outbound, z.ZodTypeDef, Text> =
+  z.object({
+    additionalProperties: z.record(z.any()).optional(),
+    format: z.lazy(() => Format$outboundSchema).optional(),
+  }).transform((v) => {
+    return {
+      ...v.additionalProperties,
+      ...remap$(v, {
+        additionalProperties: null,
+      }),
+    };
+  });
+
+export function textToJSON(text: Text): string {
+  return JSON.stringify(Text$outboundSchema.parse(text));
+}
+
+/** @internal */
+export type ResponseRequest$Outbound = {
+  input: string | Array<{ [k: string]: any }>;
+  instructions?: string | null | undefined;
+  max_output_tokens?: number | null | undefined;
+  metadata?: { [k: string]: string } | null | undefined;
+  model: string;
+  parallel_tool_calls?: boolean | null | undefined;
+  service_tier?: string | null | undefined;
+  store?: boolean | null | undefined;
+  stream?: boolean | null | undefined;
+  temperature?: number | null | undefined;
+  text?: Text$Outbound | null | undefined;
+  tool_choice?: any | undefined;
+  tools?: Array<any> | null | undefined;
+  top_p?: number | null | undefined;
+  truncation?: string | null | undefined;
+  user?: string | null | undefined;
+};
+
+/** @internal */
+export const ResponseRequest$outboundSchema: z.ZodType<
+  ResponseRequest$Outbound,
+  z.ZodTypeDef,
+  ResponseRequest
+> = z.object({
+  input: z.union([z.string(), z.array(z.record(z.any()))]),
+  instructions: z.nullable(z.string()).optional(),
+  maxOutputTokens: z.nullable(z.number().int()).optional(),
+  metadata: z.nullable(z.record(z.string())).optional(),
+  model: z.string(),
+  parallelToolCalls: z.nullable(z.boolean()).optional(),
+  serviceTier: z.nullable(z.string()).optional(),
+  store: z.nullable(z.boolean()).optional(),
+  stream: z.nullable(z.boolean()).optional(),
+  temperature: z.nullable(z.number()).optional(),
+  text: z.nullable(z.lazy(() => Text$outboundSchema)).optional(),
+  toolChoice: z.any().optional(),
+  tools: z.nullable(z.array(z.any())).optional(),
+  topP: z.nullable(z.number()).optional(),
+  truncation: z.nullable(z.string()).optional(),
+  user: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxOutputTokens: "max_output_tokens",
+    parallelToolCalls: "parallel_tool_calls",
+    serviceTier: "service_tier",
+    toolChoice: "tool_choice",
+    topP: "top_p",
+  });
+});
+
+export function responseRequestToJSON(
+  responseRequest: ResponseRequest,
+): string {
+  return JSON.stringify(ResponseRequest$outboundSchema.parse(responseRequest));
+}

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

@@ -40,6 +40,10 @@ export type SearchResponseSources = OpenEnum<typeof SearchResponseSources>;
  * How the query was interpreted and how long it took.
  */
 export type Metadata = {
+  /**
+   * 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;
   /**
    * How long the query took, in milliseconds, as a string such as '45ms'.
    */
@@ -120,6 +124,7 @@ export const Metadata$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  attribution: z.string().optional(),
   processingTime: z.string().optional(),
   queryPattern: QueryPattern$inboundSchema.optional(),
   sources: z.array(SearchResponseSources$inboundSchema).optional(),

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

@@ -247,7 +247,7 @@ export type Site = {
    */
   registeredAt?: string | null | undefined;
   /**
-   * Code for the land registry dataset the title came from.
+   * Code for the land registry the title is registered with, as it appears in `siteId`.
    */
   registry?: string | undefined;
   /**