@vepler/sdk 2.3.0 → 2.6.2

package/src/sdk/models/operations/searchstreets.ts

@@ -3,61 +3,326 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as shared from "../shared/index.js";
 
+/**
+ * Error type category
+ */
+export const SearchStreetsStreetsResponseType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Error type category
+ */
+export type SearchStreetsStreetsResponseType = ClosedEnum<
+  typeof SearchStreetsStreetsResponseType
+>;
+
+export type SearchStreetsStreetsResponseError = {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * URL to relevant documentation
+   */
+  docUrl?: string | undefined;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  /**
+   * Parameter that caused the error
+   */
+  param?: string | undefined;
+  /**
+   * Error type category
+   */
+  type: SearchStreetsStreetsResponseType;
+};
+
+/**
+ * Error response
+ */
+export type SearchStreetsStreetsResponseResponseBody = {
+  error: SearchStreetsStreetsResponseError;
+};
+
+/**
+ * Error type category
+ */
+export const SearchStreetsStreetsType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Error type category
+ */
+export type SearchStreetsStreetsType = ClosedEnum<
+  typeof SearchStreetsStreetsType
+>;
+
+export type SearchStreetsStreetsError = {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * URL to relevant documentation
+   */
+  docUrl?: string | undefined;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  /**
+   * Parameter that caused the error
+   */
+  param?: string | undefined;
+  /**
+   * Error type category
+   */
+  type: SearchStreetsStreetsType;
+};
+
+/**
+ * Error response
+ */
+export type SearchStreetsStreetsResponseBody = {
+  error: SearchStreetsStreetsError;
+};
+
+/**
+ * Error type category
+ */
+export const SearchStreetsType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Error type category
+ */
+export type SearchStreetsType = ClosedEnum<typeof SearchStreetsType>;
+
+export type SearchStreetsError = {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * URL to relevant documentation
+   */
+  docUrl?: string | undefined;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  /**
+   * Parameter that caused the error
+   */
+  param?: string | undefined;
+  /**
+   * Error type category
+   */
+  type: SearchStreetsType;
+};
+
+/**
+ * Error response
+ */
+export type SearchStreetsResponseBody = {
+  error: SearchStreetsError;
+};
+
 export type SearchStreetsResponse =
   | shared.StreetQueryResponse
-  | shared.ErrorResponse;
+  | SearchStreetsResponseBody
+  | SearchStreetsStreetsResponseBody
+  | SearchStreetsStreetsResponseResponseBody;
 
 /** @internal */
-export const SearchStreetsResponse$inboundSchema: z.ZodType<
-  SearchStreetsResponse,
+export const SearchStreetsStreetsResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof SearchStreetsStreetsResponseType
+> = z.nativeEnum(SearchStreetsStreetsResponseType);
+
+/** @internal */
+export const SearchStreetsStreetsResponseError$inboundSchema: z.ZodType<
+  SearchStreetsStreetsResponseError,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  shared.StreetQueryResponse$inboundSchema,
-  shared.ErrorResponse$inboundSchema,
-]);
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  type: SearchStreetsStreetsResponseType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function searchStreetsStreetsResponseErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchStreetsStreetsResponseError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchStreetsStreetsResponseError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchStreetsStreetsResponseError' from JSON`,
+  );
+}
 
 /** @internal */
-export type SearchStreetsResponse$Outbound =
-  | shared.StreetQueryResponse$Outbound
-  | shared.ErrorResponse$Outbound;
+export const SearchStreetsStreetsResponseResponseBody$inboundSchema: z.ZodType<
+  SearchStreetsStreetsResponseResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => SearchStreetsStreetsResponseError$inboundSchema),
+});
+
+export function searchStreetsStreetsResponseResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  SearchStreetsStreetsResponseResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SearchStreetsStreetsResponseResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'SearchStreetsStreetsResponseResponseBody' from JSON`,
+  );
+}
 
 /** @internal */
-export const SearchStreetsResponse$outboundSchema: z.ZodType<
-  SearchStreetsResponse$Outbound,
+export const SearchStreetsStreetsType$inboundSchema: z.ZodNativeEnum<
+  typeof SearchStreetsStreetsType
+> = z.nativeEnum(SearchStreetsStreetsType);
+
+/** @internal */
+export const SearchStreetsStreetsError$inboundSchema: z.ZodType<
+  SearchStreetsStreetsError,
   z.ZodTypeDef,
-  SearchStreetsResponse
-> = z.union([
-  shared.StreetQueryResponse$outboundSchema,
-  shared.ErrorResponse$outboundSchema,
-]);
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  type: SearchStreetsStreetsType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace SearchStreetsResponse$ {
-  /** @deprecated use `SearchStreetsResponse$inboundSchema` instead. */
-  export const inboundSchema = SearchStreetsResponse$inboundSchema;
-  /** @deprecated use `SearchStreetsResponse$outboundSchema` instead. */
-  export const outboundSchema = SearchStreetsResponse$outboundSchema;
-  /** @deprecated use `SearchStreetsResponse$Outbound` instead. */
-  export type Outbound = SearchStreetsResponse$Outbound;
+export function searchStreetsStreetsErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchStreetsStreetsError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchStreetsStreetsError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchStreetsStreetsError' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchStreetsStreetsResponseBody$inboundSchema: z.ZodType<
+  SearchStreetsStreetsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => SearchStreetsStreetsError$inboundSchema),
+});
+
+export function searchStreetsStreetsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchStreetsStreetsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchStreetsStreetsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchStreetsStreetsResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchStreetsType$inboundSchema: z.ZodNativeEnum<
+  typeof SearchStreetsType
+> = z.nativeEnum(SearchStreetsType);
+
+/** @internal */
+export const SearchStreetsError$inboundSchema: z.ZodType<
+  SearchStreetsError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  type: SearchStreetsType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function searchStreetsErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchStreetsError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchStreetsError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchStreetsError' from JSON`,
+  );
 }
 
-export function searchStreetsResponseToJSON(
-  searchStreetsResponse: SearchStreetsResponse,
-): string {
-  return JSON.stringify(
-    SearchStreetsResponse$outboundSchema.parse(searchStreetsResponse),
+/** @internal */
+export const SearchStreetsResponseBody$inboundSchema: z.ZodType<
+  SearchStreetsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => SearchStreetsError$inboundSchema),
+});
+
+export function searchStreetsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchStreetsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchStreetsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchStreetsResponseBody' from JSON`,
   );
 }
 
+/** @internal */
+export const SearchStreetsResponse$inboundSchema: z.ZodType<
+  SearchStreetsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  shared.StreetQueryResponse$inboundSchema,
+  z.lazy(() => SearchStreetsResponseBody$inboundSchema),
+  z.lazy(() => SearchStreetsStreetsResponseBody$inboundSchema),
+  z.lazy(() => SearchStreetsStreetsResponseResponseBody$inboundSchema),
+]);
+
 export function searchStreetsResponseFromJSON(
   jsonString: string,
 ): SafeParseResult<SearchStreetsResponse, SDKValidationError> {

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

@@ -0,0 +1,42 @@
+/*
+ * 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";
+
+/**
+ * 95% confidence interval for the valuation
+ */
+export type AVMConfidenceInterval = {
+  /**
+   * Lower bound of 95% confidence interval
+   */
+  lower: number;
+  /**
+   * Upper bound of 95% confidence interval
+   */
+  upper: number;
+};
+
+/** @internal */
+export const AVMConfidenceInterval$inboundSchema: z.ZodType<
+  AVMConfidenceInterval,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lower: z.number(),
+  upper: z.number(),
+});
+
+export function avmConfidenceIntervalFromJSON(
+  jsonString: string,
+): SafeParseResult<AVMConfidenceInterval, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AVMConfidenceInterval$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AVMConfidenceInterval' from JSON`,
+  );
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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";
+
+/**
+ * Prediction metadata including model and data quality information
+ */
+export type AVMMetadata = {
+  /**
+   * Number of comparable properties used in the valuation
+   */
+  comparablesCount?: number | undefined;
+  /**
+   * Overall confidence score (0-1) based on data quality and model agreement
+   */
+  confidenceScore: number;
+  /**
+   * Name of the ML ensemble model used
+   */
+  modelName: string;
+};
+
+/** @internal */
+export const AVMMetadata$inboundSchema: z.ZodType<
+  AVMMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  comparablesCount: z.number().int().optional(),
+  confidenceScore: z.number(),
+  modelName: z.string(),
+});
+
+export function avmMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<AVMMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AVMMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AVMMetadata' from JSON`,
+  );
+}

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

@@ -0,0 +1,191 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Property condition
+ */
+export const Condition = {
+  Poor: "poor",
+  Average: "average",
+  Good: "good",
+  Excellent: "excellent",
+  NewBuild: "newBuild",
+} as const;
+/**
+ * Property condition
+ */
+export type Condition = ClosedEnum<typeof Condition>;
+
+/**
+ * Energy Performance Certificate rating
+ */
+export const Epc = {
+  A: "A",
+  B: "B",
+  C: "C",
+  D: "D",
+  E: "E",
+  F: "F",
+  G: "G",
+} as const;
+/**
+ * Energy Performance Certificate rating
+ */
+export type Epc = ClosedEnum<typeof Epc>;
+
+/**
+ * Type of property
+ */
+export const PropertyType = {
+  Detached: "detached",
+  SemiDetached: "semiDetached",
+  Terraced: "terraced",
+  Flat: "flat",
+  Bungalow: "bungalow",
+  Other: "other",
+} as const;
+/**
+ * Type of property
+ */
+export type PropertyType = ClosedEnum<typeof PropertyType>;
+
+/**
+ * Type of transaction - sale or rental valuation
+ */
+export const TransactionType = {
+  Sale: "sale",
+  Rent: "rent",
+} as const;
+/**
+ * Type of transaction - sale or rental valuation
+ */
+export type TransactionType = ClosedEnum<typeof TransactionType>;
+
+export type AVMPredictRequest = {
+  /**
+   * Number of bathrooms
+   */
+  baths?: number | undefined;
+  /**
+   * Number of bedrooms
+   */
+  beds: number;
+  /**
+   * Property condition
+   */
+  condition?: Condition | undefined;
+  /**
+   * Energy Performance Certificate rating
+   */
+  epc?: Epc | undefined;
+  /**
+   * Floor area in square metres
+   */
+  floorArea?: number | undefined;
+  /**
+   * Price to rate against market value (requires ratePrice: true)
+   */
+  inputPrice?: number | undefined;
+  /**
+   * Latitude coordinate (alternative to postcode, requires longitude)
+   */
+  latitude?: number | undefined;
+  /**
+   * Current listing price (for comparison)
+   */
+  listingPrice?: number | undefined;
+  /**
+   * Longitude coordinate (alternative to postcode, requires latitude)
+   */
+  longitude?: number | undefined;
+  /**
+   * UK postcode for property location (required if latitude/longitude not provided)
+   */
+  postcode?: string | undefined;
+  /**
+   * Type of property
+   */
+  propertyType: PropertyType;
+  /**
+   * Whether to rate the input price against estimated market value
+   */
+  ratePrice?: boolean | undefined;
+  /**
+   * Type of transaction - sale or rental valuation
+   */
+  transactionType?: TransactionType | undefined;
+  /**
+   * Year the property was built
+   */
+  yearBuilt?: number | undefined;
+};
+
+/** @internal */
+export const Condition$outboundSchema: z.ZodNativeEnum<typeof Condition> = z
+  .nativeEnum(Condition);
+
+/** @internal */
+export const Epc$outboundSchema: z.ZodNativeEnum<typeof Epc> = z.nativeEnum(
+  Epc,
+);
+
+/** @internal */
+export const PropertyType$outboundSchema: z.ZodNativeEnum<typeof PropertyType> =
+  z.nativeEnum(PropertyType);
+
+/** @internal */
+export const TransactionType$outboundSchema: z.ZodNativeEnum<
+  typeof TransactionType
+> = z.nativeEnum(TransactionType);
+
+/** @internal */
+export type AVMPredictRequest$Outbound = {
+  baths?: number | undefined;
+  beds: number;
+  condition?: string | undefined;
+  epc?: string | undefined;
+  floorArea?: number | undefined;
+  inputPrice?: number | undefined;
+  latitude?: number | undefined;
+  listingPrice?: number | undefined;
+  longitude?: number | undefined;
+  postcode?: string | undefined;
+  propertyType: string;
+  ratePrice?: boolean | undefined;
+  transactionType: string;
+  yearBuilt?: number | undefined;
+};
+
+/** @internal */
+export const AVMPredictRequest$outboundSchema: z.ZodType<
+  AVMPredictRequest$Outbound,
+  z.ZodTypeDef,
+  AVMPredictRequest
+> = z.object({
+  baths: z.number().int().optional(),
+  beds: z.number().int(),
+  condition: Condition$outboundSchema.optional(),
+  epc: Epc$outboundSchema.optional(),
+  floorArea: z.number().optional(),
+  inputPrice: z.number().optional(),
+  latitude: z.number().optional(),
+  listingPrice: z.number().optional(),
+  longitude: z.number().optional(),
+  postcode: z.string().optional(),
+  propertyType: PropertyType$outboundSchema,
+  ratePrice: z.boolean().optional(),
+  transactionType: TransactionType$outboundSchema.default("sale"),
+  yearBuilt: z.number().int().optional(),
+});
+
+export function avmPredictRequestToJSON(
+  avmPredictRequest: AVMPredictRequest,
+): string {
+  return JSON.stringify(
+    AVMPredictRequest$outboundSchema.parse(avmPredictRequest),
+  );
+}

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

@@ -0,0 +1,66 @@
+/*
+ * 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 {
+  AVMConfidenceInterval,
+  AVMConfidenceInterval$inboundSchema,
+} from "./avmconfidenceinterval.js";
+import { AVMMetadata, AVMMetadata$inboundSchema } from "./avmmetadata.js";
+import {
+  AVMPriceRating,
+  AVMPriceRating$inboundSchema,
+} from "./avmpricerating.js";
+
+/**
+ * Successful property valuation response
+ */
+export type AVMPredictResponse = {
+  /**
+   * 95% confidence interval for the valuation
+   */
+  confidenceInterval: AVMConfidenceInterval;
+  /**
+   * Estimated property value in GBP (£)
+   */
+  estimatedPrice: number;
+  /**
+   * Prediction metadata including model and data quality information
+   */
+  metadata?: AVMMetadata | undefined;
+  /**
+   * Price rating analysis (only included when ratePrice: true and inputPrice provided)
+   */
+  priceRatingInfo?: AVMPriceRating | undefined;
+  /**
+   * Indicates successful prediction
+   */
+  success: boolean;
+};
+
+/** @internal */
+export const AVMPredictResponse$inboundSchema: z.ZodType<
+  AVMPredictResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidenceInterval: AVMConfidenceInterval$inboundSchema,
+  estimatedPrice: z.number(),
+  metadata: AVMMetadata$inboundSchema.optional(),
+  priceRatingInfo: AVMPriceRating$inboundSchema.optional(),
+  success: z.boolean(),
+});
+
+export function avmPredictResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AVMPredictResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AVMPredictResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AVMPredictResponse' from JSON`,
+  );
+}