@vepler/sdk 2.24.2 → 2.28.0

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

@@ -0,0 +1,519 @@
+/*
+ * 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 {
+  AnalysisComparable,
+  AnalysisComparable$inboundSchema,
+} from "./analysiscomparable.js";
+import {
+  AVMConfidenceInterval,
+  AVMConfidenceInterval$inboundSchema,
+} from "./avmconfidenceinterval.js";
+import {
+  HistoricalValuation,
+  HistoricalValuation$inboundSchema,
+} from "./historicalvaluation.js";
+
+/**
+ * Breakdown by quality tier
+ */
+export type TierSummary = {
+  acceptable: number;
+  excellent: number;
+  excluded: number;
+  good: number;
+};
+
+/**
+ * Comparable properties analysis
+ */
+export type Comparables = {
+  /**
+   * List of comparable properties with tier info
+   */
+  list: Array<AnalysisComparable>;
+  /**
+   * Breakdown by quality tier
+   */
+  tierSummary: TierSummary;
+  /**
+   * Total comparable properties found
+   */
+  total: number;
+};
+
+/**
+ * Detailed confidence metrics
+ */
+export type Confidence = {
+  dataQuality?: number | undefined;
+  modelAgreement?: number | undefined;
+  score?: number | undefined;
+};
+
+export type Change12Month = {
+  amount: number;
+  percentage: number;
+};
+
+export type Change6Month = {
+  amount: number;
+  percentage: number;
+};
+
+export const Trend = {
+  Rising: "rising",
+  Stable: "stable",
+  Falling: "falling",
+} as const;
+export type Trend = ClosedEnum<typeof Trend>;
+
+export type Summary = {
+  change12Month?: Change12Month | undefined;
+  change6Month?: Change6Month | undefined;
+  trend: Trend;
+};
+
+/**
+ * Historical valuation data
+ */
+export type History = {
+  summary: Summary;
+  valuations: Array<HistoricalValuation>;
+};
+
+export const Severity = {
+  Error: "error",
+  Warning: "warning",
+  Info: "info",
+} as const;
+export type Severity = ClosedEnum<typeof Severity>;
+
+export type Issues = {
+  message: string;
+  severity: Severity;
+};
+
+/**
+ * Price range of comparables
+ */
+export type PriceRange = {
+  max: number;
+  min: number;
+};
+
+/**
+ * Market statistics from comparables
+ */
+export type MarketStats = {
+  /**
+   * Mean price of comparables
+   */
+  meanPrice: number;
+  /**
+   * Median price of comparables
+   */
+  medianPrice: number;
+  /**
+   * Median price per square metre
+   */
+  medianPricePerSqm?: number | undefined;
+  /**
+   * Price range of comparables
+   */
+  priceRange: PriceRange;
+  /**
+   * Weighted average price
+   */
+  weightedAverage: number;
+};
+
+/**
+ * Subject property characteristics used in valuation
+ */
+export type PropertyFactors = {
+  baths?: number | undefined;
+  beds?: number | undefined;
+  condition?: string | undefined;
+  epc?: string | undefined;
+  floorArea?: number | undefined;
+  propertyType?: string | undefined;
+  yearBuilt?: number | undefined;
+};
+
+export type SaleHistory = {
+  date: string;
+  price: number;
+};
+
+/**
+ * Current valuation result
+ */
+export type Valuation = {
+  /**
+   * Confidence score (0-1)
+   */
+  confidence: number;
+  /**
+   * 95% confidence interval for the valuation
+   */
+  confidenceInterval: AVMConfidenceInterval;
+  /**
+   * Estimated property value in GBP
+   */
+  estimatedPrice: number;
+  /**
+   * Agreement level between ML models (0-1)
+   */
+  modelAgreement?: number | undefined;
+};
+
+/**
+ * Comprehensive AVM analysis response with comparables, market stats, and history
+ */
+export type AVMAnalysisResponse = {
+  /**
+   * Comparable properties analysis
+   */
+  comparables: Comparables;
+  /**
+   * Detailed confidence metrics
+   */
+  confidence: Confidence;
+  /**
+   * Historical valuation data
+   */
+  history?: History | undefined;
+  /**
+   * Data quality issues and warnings
+   */
+  issues: Array<Issues>;
+  /**
+   * Market statistics from comparables
+   */
+  marketStats: MarketStats;
+  /**
+   * Subject property characteristics used in valuation
+   */
+  propertyFactors: PropertyFactors;
+  /**
+   * Subject property sale history
+   */
+  saleHistory?: Array<SaleHistory> | undefined;
+  /**
+   * Indicates successful analysis
+   */
+  success: boolean;
+  /**
+   * Current valuation result
+   */
+  valuation: Valuation;
+};
+
+/** @internal */
+export const TierSummary$inboundSchema: z.ZodType<
+  TierSummary,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  acceptable: z.number().int(),
+  excellent: z.number().int(),
+  excluded: z.number().int(),
+  good: z.number().int(),
+});
+
+export function tierSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<TierSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TierSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TierSummary' from JSON`,
+  );
+}
+
+/** @internal */
+export const Comparables$inboundSchema: z.ZodType<
+  Comparables,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  list: z.array(AnalysisComparable$inboundSchema),
+  tierSummary: z.lazy(() => TierSummary$inboundSchema),
+  total: z.number().int(),
+});
+
+export function comparablesFromJSON(
+  jsonString: string,
+): SafeParseResult<Comparables, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Comparables$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Comparables' from JSON`,
+  );
+}
+
+/** @internal */
+export const Confidence$inboundSchema: z.ZodType<
+  Confidence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  dataQuality: z.number().optional(),
+  modelAgreement: z.number().optional(),
+  score: z.number().optional(),
+});
+
+export function confidenceFromJSON(
+  jsonString: string,
+): SafeParseResult<Confidence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Confidence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Confidence' from JSON`,
+  );
+}
+
+/** @internal */
+export const Change12Month$inboundSchema: z.ZodType<
+  Change12Month,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: z.number(),
+  percentage: z.number(),
+});
+
+export function change12MonthFromJSON(
+  jsonString: string,
+): SafeParseResult<Change12Month, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Change12Month$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Change12Month' from JSON`,
+  );
+}
+
+/** @internal */
+export const Change6Month$inboundSchema: z.ZodType<
+  Change6Month,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: z.number(),
+  percentage: z.number(),
+});
+
+export function change6MonthFromJSON(
+  jsonString: string,
+): SafeParseResult<Change6Month, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Change6Month$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Change6Month' from JSON`,
+  );
+}
+
+/** @internal */
+export const Trend$inboundSchema: z.ZodNativeEnum<typeof Trend> = z.nativeEnum(
+  Trend,
+);
+
+/** @internal */
+export const Summary$inboundSchema: z.ZodType<Summary, z.ZodTypeDef, unknown> =
+  z.object({
+    change12Month: z.lazy(() => Change12Month$inboundSchema).optional(),
+    change6Month: z.lazy(() => Change6Month$inboundSchema).optional(),
+    trend: Trend$inboundSchema,
+  });
+
+export function summaryFromJSON(
+  jsonString: string,
+): SafeParseResult<Summary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Summary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Summary' from JSON`,
+  );
+}
+
+/** @internal */
+export const History$inboundSchema: z.ZodType<History, z.ZodTypeDef, unknown> =
+  z.object({
+    summary: z.lazy(() => Summary$inboundSchema),
+    valuations: z.array(HistoricalValuation$inboundSchema),
+  });
+
+export function historyFromJSON(
+  jsonString: string,
+): SafeParseResult<History, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => History$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'History' from JSON`,
+  );
+}
+
+/** @internal */
+export const Severity$inboundSchema: z.ZodNativeEnum<typeof Severity> = z
+  .nativeEnum(Severity);
+
+/** @internal */
+export const Issues$inboundSchema: z.ZodType<Issues, z.ZodTypeDef, unknown> = z
+  .object({
+    message: z.string(),
+    severity: Severity$inboundSchema,
+  });
+
+export function issuesFromJSON(
+  jsonString: string,
+): SafeParseResult<Issues, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Issues$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Issues' from JSON`,
+  );
+}
+
+/** @internal */
+export const PriceRange$inboundSchema: z.ZodType<
+  PriceRange,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  max: z.number(),
+  min: z.number(),
+});
+
+export function priceRangeFromJSON(
+  jsonString: string,
+): SafeParseResult<PriceRange, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PriceRange$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PriceRange' from JSON`,
+  );
+}
+
+/** @internal */
+export const MarketStats$inboundSchema: z.ZodType<
+  MarketStats,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  meanPrice: z.number(),
+  medianPrice: z.number(),
+  medianPricePerSqm: z.number().optional(),
+  priceRange: z.lazy(() => PriceRange$inboundSchema),
+  weightedAverage: z.number(),
+});
+
+export function marketStatsFromJSON(
+  jsonString: string,
+): SafeParseResult<MarketStats, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MarketStats$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MarketStats' from JSON`,
+  );
+}
+
+/** @internal */
+export const PropertyFactors$inboundSchema: z.ZodType<
+  PropertyFactors,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  baths: z.number().int().optional(),
+  beds: z.number().int().optional(),
+  condition: z.string().optional(),
+  epc: z.string().optional(),
+  floorArea: z.number().optional(),
+  propertyType: z.string().optional(),
+  yearBuilt: z.number().int().optional(),
+});
+
+export function propertyFactorsFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyFactors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PropertyFactors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyFactors' from JSON`,
+  );
+}
+
+/** @internal */
+export const SaleHistory$inboundSchema: z.ZodType<
+  SaleHistory,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  date: z.string(),
+  price: z.number(),
+});
+
+export function saleHistoryFromJSON(
+  jsonString: string,
+): SafeParseResult<SaleHistory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SaleHistory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SaleHistory' from JSON`,
+  );
+}
+
+/** @internal */
+export const Valuation$inboundSchema: z.ZodType<
+  Valuation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number(),
+  confidenceInterval: AVMConfidenceInterval$inboundSchema,
+  estimatedPrice: z.number(),
+  modelAgreement: z.number().optional(),
+});
+
+export function valuationFromJSON(
+  jsonString: string,
+): SafeParseResult<Valuation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Valuation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Valuation' from JSON`,
+  );
+}
+
+/** @internal */
+export const AVMAnalysisResponse$inboundSchema: z.ZodType<
+  AVMAnalysisResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  comparables: z.lazy(() => Comparables$inboundSchema),
+  confidence: z.lazy(() => Confidence$inboundSchema),
+  history: z.lazy(() => History$inboundSchema).optional(),
+  issues: z.array(z.lazy(() => Issues$inboundSchema)),
+  marketStats: z.lazy(() => MarketStats$inboundSchema),
+  propertyFactors: z.lazy(() => PropertyFactors$inboundSchema),
+  saleHistory: z.array(z.lazy(() => SaleHistory$inboundSchema)).optional(),
+  success: z.boolean(),
+  valuation: z.lazy(() => Valuation$inboundSchema),
+});
+
+export function avmAnalysisResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AVMAnalysisResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AVMAnalysisResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AVMAnalysisResponse' from JSON`,
+  );
+}

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

@@ -66,14 +66,16 @@ export type PropertyType = ClosedEnum<typeof PropertyType>;
 /**
  * Type of transaction - sale or rental valuation
  */
-export const TransactionType = {
+export const AVMPredictByLocationRequestTransactionType = {
   Sale: "sale",
   Rent: "rent",
 } as const;
 /**
  * Type of transaction - sale or rental valuation
  */
-export type TransactionType = ClosedEnum<typeof TransactionType>;
+export type AVMPredictByLocationRequestTransactionType = ClosedEnum<
+  typeof AVMPredictByLocationRequestTransactionType
+>;
 
 /**
  * Request to predict property value by location ID
@@ -122,7 +124,7 @@ export type AVMPredictByLocationRequest = {
   /**
    * Type of transaction - sale or rental valuation
    */
-  transactionType?: TransactionType | undefined;
+  transactionType?: AVMPredictByLocationRequestTransactionType | undefined;
   /**
    * Override year the property was built
    */
@@ -143,9 +145,9 @@ export const PropertyType$outboundSchema: z.ZodNativeEnum<typeof PropertyType> =
   z.nativeEnum(PropertyType);
 
 /** @internal */
-export const TransactionType$outboundSchema: z.ZodNativeEnum<
-  typeof TransactionType
-> = z.nativeEnum(TransactionType);
+export const AVMPredictByLocationRequestTransactionType$outboundSchema:
+  z.ZodNativeEnum<typeof AVMPredictByLocationRequestTransactionType> = z
+    .nativeEnum(AVMPredictByLocationRequestTransactionType);
 
 /** @internal */
 export type AVMPredictByLocationRequest$Outbound = {
@@ -179,7 +181,8 @@ export const AVMPredictByLocationRequest$outboundSchema: z.ZodType<
   locationId: z.string(),
   propertyType: PropertyType$outboundSchema.optional(),
   ratePrice: z.boolean().optional(),
-  transactionType: TransactionType$outboundSchema.default("sale"),
+  transactionType: AVMPredictByLocationRequestTransactionType$outboundSchema
+    .default("sale"),
   yearBuilt: z.number().int().optional(),
 });
 

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

@@ -64,7 +64,7 @@ export type Status = ClosedEnum<typeof Status>;
 /**
  * Council type classification
  */
-export const Type = {
+export const CouncilType = {
   Unitary: "unitary",
   Metropolitan: "metropolitan",
   County: "county",
@@ -75,7 +75,7 @@ export const Type = {
 /**
  * Council type classification
  */
-export type Type = ClosedEnum<typeof Type>;
+export type CouncilType = ClosedEnum<typeof CouncilType>;
 
 export type Council = {
   branding?: CouncilBranding | undefined;
@@ -129,7 +129,7 @@ export type Council = {
   /**
    * Council type classification
    */
-  type: Type | null;
+  type: CouncilType | null;
   /**
    * Last update timestamp in ISO format
    */
@@ -153,9 +153,8 @@ export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
   .nativeEnum(Status);
 
 /** @internal */
-export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
-  Type,
-);
+export const CouncilType$inboundSchema: z.ZodNativeEnum<typeof CouncilType> = z
+  .nativeEnum(CouncilType);
 
 /** @internal */
 export const Council$inboundSchema: z.ZodType<Council, z.ZodTypeDef, unknown> =
@@ -175,7 +174,7 @@ export const Council$inboundSchema: z.ZodType<Council, z.ZodTypeDef, unknown> =
     providerId: z.nullable(z.string()),
     serviceUrls: CouncilServiceUrls$inboundSchema.optional(),
     status: Status$inboundSchema,
-    type: z.nullable(Type$inboundSchema),
+    type: z.nullable(CouncilType$inboundSchema),
     updatedAt: z.string(),
     verified: z.boolean(),
   });

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

@@ -0,0 +1,85 @@
+/*
+ * 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
+ */
+export type ConfidenceInterval = {
+  lower: number;
+  upper: number;
+};
+
+/**
+ * Point-in-time valuation snapshot
+ */
+export type HistoricalValuation = {
+  /**
+   * Number of comparables used
+   */
+  comparablesCount: number;
+  /**
+   * Confidence score (0-1)
+   */
+  confidence: number;
+  /**
+   * 95% confidence interval
+   */
+  confidenceInterval: ConfidenceInterval;
+  /**
+   * Valuation date (YYYY-MM-DD)
+   */
+  date: string;
+  /**
+   * Estimated price at this date
+   */
+  estimatedPrice: number;
+};
+
+/** @internal */
+export const ConfidenceInterval$inboundSchema: z.ZodType<
+  ConfidenceInterval,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lower: z.number(),
+  upper: z.number(),
+});
+
+export function confidenceIntervalFromJSON(
+  jsonString: string,
+): SafeParseResult<ConfidenceInterval, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConfidenceInterval$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConfidenceInterval' from JSON`,
+  );
+}
+
+/** @internal */
+export const HistoricalValuation$inboundSchema: z.ZodType<
+  HistoricalValuation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  comparablesCount: z.number().int(),
+  confidence: z.number(),
+  confidenceInterval: z.lazy(() => ConfidenceInterval$inboundSchema),
+  date: z.string(),
+  estimatedPrice: z.number(),
+});
+
+export function historicalValuationFromJSON(
+  jsonString: string,
+): SafeParseResult<HistoricalValuation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HistoricalValuation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HistoricalValuation' from JSON`,
+  );
+}