@vepler/sdk 2.24.1 → 2.28.0

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

@@ -13,7 +13,7 @@ import * as shared from "../shared/index.js";
 /**
  * Error type category
  */
-export const PredictPropertyValueAVMType = {
+export const PredictPropertyValueAVMResponseType = {
   ApiError: "api_error",
   InvalidRequestError: "invalid_request_error",
   AuthenticationError: "authentication_error",
@@ -22,11 +22,11 @@ export const PredictPropertyValueAVMType = {
 /**
  * Error type category
  */
-export type PredictPropertyValueAVMType = ClosedEnum<
-  typeof PredictPropertyValueAVMType
+export type PredictPropertyValueAVMResponseType = ClosedEnum<
+  typeof PredictPropertyValueAVMResponseType
 >;
 
-export type PredictPropertyValueAVMError = {
+export type PredictPropertyValueAVMResponseError = {
   /**
    * Machine-readable error code
    */
@@ -46,20 +46,20 @@ export type PredictPropertyValueAVMError = {
   /**
    * Error type category
    */
-  type: PredictPropertyValueAVMType;
+  type: PredictPropertyValueAVMResponseType;
 };
 
 /**
  * Error response
  */
 export type PredictPropertyValueAVMResponseResponseBody = {
-  error: PredictPropertyValueAVMError;
+  error: PredictPropertyValueAVMResponseError;
 };
 
 /**
  * Error type category
  */
-export const PredictPropertyValueType = {
+export const PredictPropertyValueAVMType = {
   ApiError: "api_error",
   InvalidRequestError: "invalid_request_error",
   AuthenticationError: "authentication_error",
@@ -68,11 +68,11 @@ export const PredictPropertyValueType = {
 /**
  * Error type category
  */
-export type PredictPropertyValueType = ClosedEnum<
-  typeof PredictPropertyValueType
+export type PredictPropertyValueAVMType = ClosedEnum<
+  typeof PredictPropertyValueAVMType
 >;
 
-export type PredictPropertyValueError = {
+export type PredictPropertyValueAVMError = {
   /**
    * Machine-readable error code
    */
@@ -92,20 +92,20 @@ export type PredictPropertyValueError = {
   /**
    * Error type category
    */
-  type: PredictPropertyValueType;
+  type: PredictPropertyValueAVMType;
 };
 
 /**
  * Error response
  */
 export type PredictPropertyValueAVMResponseBody = {
-  error: PredictPropertyValueError;
+  error: PredictPropertyValueAVMError;
 };
 
 /**
  * Error type category
  */
-export const PredictPropertyValueAVMResponseType = {
+export const PredictPropertyValueType = {
   ApiError: "api_error",
   InvalidRequestError: "invalid_request_error",
   AuthenticationError: "authentication_error",
@@ -114,11 +114,11 @@ export const PredictPropertyValueAVMResponseType = {
 /**
  * Error type category
  */
-export type PredictPropertyValueAVMResponseType = ClosedEnum<
-  typeof PredictPropertyValueAVMResponseType
+export type PredictPropertyValueType = ClosedEnum<
+  typeof PredictPropertyValueType
 >;
 
-export type ErrorT = {
+export type PredictPropertyValueError = {
   /**
    * Machine-readable error code
    */
@@ -138,14 +138,14 @@ export type ErrorT = {
   /**
    * Error type category
    */
-  type: PredictPropertyValueAVMResponseType;
+  type: PredictPropertyValueType;
 };
 
 /**
  * Error response
  */
 export type PredictPropertyValueResponseBody = {
-  error: ErrorT;
+  error: PredictPropertyValueError;
 };
 
 export type PredictPropertyValueResponse =
@@ -155,13 +155,13 @@ export type PredictPropertyValueResponse =
   | PredictPropertyValueAVMResponseResponseBody;
 
 /** @internal */
-export const PredictPropertyValueAVMType$inboundSchema: z.ZodNativeEnum<
-  typeof PredictPropertyValueAVMType
-> = z.nativeEnum(PredictPropertyValueAVMType);
+export const PredictPropertyValueAVMResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof PredictPropertyValueAVMResponseType
+> = z.nativeEnum(PredictPropertyValueAVMResponseType);
 
 /** @internal */
-export const PredictPropertyValueAVMError$inboundSchema: z.ZodType<
-  PredictPropertyValueAVMError,
+export const PredictPropertyValueAVMResponseError$inboundSchema: z.ZodType<
+  PredictPropertyValueAVMResponseError,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -169,20 +169,21 @@ export const PredictPropertyValueAVMError$inboundSchema: z.ZodType<
   doc_url: z.string().optional(),
   message: z.string(),
   param: z.string().optional(),
-  type: PredictPropertyValueAVMType$inboundSchema,
+  type: PredictPropertyValueAVMResponseType$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "doc_url": "docUrl",
   });
 });
 
-export function predictPropertyValueAVMErrorFromJSON(
+export function predictPropertyValueAVMResponseErrorFromJSON(
   jsonString: string,
-): SafeParseResult<PredictPropertyValueAVMError, SDKValidationError> {
+): SafeParseResult<PredictPropertyValueAVMResponseError, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PredictPropertyValueAVMError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PredictPropertyValueAVMError' from JSON`,
+    (x) =>
+      PredictPropertyValueAVMResponseError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PredictPropertyValueAVMResponseError' from JSON`,
   );
 }
 
@@ -193,7 +194,7 @@ export const PredictPropertyValueAVMResponseResponseBody$inboundSchema:
     z.ZodTypeDef,
     unknown
   > = z.object({
-    error: z.lazy(() => PredictPropertyValueAVMError$inboundSchema),
+    error: z.lazy(() => PredictPropertyValueAVMResponseError$inboundSchema),
   });
 
 export function predictPropertyValueAVMResponseResponseBodyFromJSON(
@@ -213,13 +214,13 @@ export function predictPropertyValueAVMResponseResponseBodyFromJSON(
 }
 
 /** @internal */
-export const PredictPropertyValueType$inboundSchema: z.ZodNativeEnum<
-  typeof PredictPropertyValueType
-> = z.nativeEnum(PredictPropertyValueType);
+export const PredictPropertyValueAVMType$inboundSchema: z.ZodNativeEnum<
+  typeof PredictPropertyValueAVMType
+> = z.nativeEnum(PredictPropertyValueAVMType);
 
 /** @internal */
-export const PredictPropertyValueError$inboundSchema: z.ZodType<
-  PredictPropertyValueError,
+export const PredictPropertyValueAVMError$inboundSchema: z.ZodType<
+  PredictPropertyValueAVMError,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -227,20 +228,20 @@ export const PredictPropertyValueError$inboundSchema: z.ZodType<
   doc_url: z.string().optional(),
   message: z.string(),
   param: z.string().optional(),
-  type: PredictPropertyValueType$inboundSchema,
+  type: PredictPropertyValueAVMType$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "doc_url": "docUrl",
   });
 });
 
-export function predictPropertyValueErrorFromJSON(
+export function predictPropertyValueAVMErrorFromJSON(
   jsonString: string,
-): SafeParseResult<PredictPropertyValueError, SDKValidationError> {
+): SafeParseResult<PredictPropertyValueAVMError, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PredictPropertyValueError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PredictPropertyValueError' from JSON`,
+    (x) => PredictPropertyValueAVMError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PredictPropertyValueAVMError' from JSON`,
   );
 }
 
@@ -250,7 +251,7 @@ export const PredictPropertyValueAVMResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  error: z.lazy(() => PredictPropertyValueError$inboundSchema),
+  error: z.lazy(() => PredictPropertyValueAVMError$inboundSchema),
 });
 
 export function predictPropertyValueAVMResponseBodyFromJSON(
@@ -265,31 +266,34 @@ export function predictPropertyValueAVMResponseBodyFromJSON(
 }
 
 /** @internal */
-export const PredictPropertyValueAVMResponseType$inboundSchema: z.ZodNativeEnum<
-  typeof PredictPropertyValueAVMResponseType
-> = z.nativeEnum(PredictPropertyValueAVMResponseType);
+export const PredictPropertyValueType$inboundSchema: z.ZodNativeEnum<
+  typeof PredictPropertyValueType
+> = z.nativeEnum(PredictPropertyValueType);
 
 /** @internal */
-export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
-  .object({
-    code: z.string().optional(),
-    doc_url: z.string().optional(),
-    message: z.string(),
-    param: z.string().optional(),
-    type: PredictPropertyValueAVMResponseType$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "doc_url": "docUrl",
-    });
+export const PredictPropertyValueError$inboundSchema: z.ZodType<
+  PredictPropertyValueError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  type: PredictPropertyValueType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
   });
+});
 
-export function errorFromJSON(
+export function predictPropertyValueErrorFromJSON(
   jsonString: string,
-): SafeParseResult<ErrorT, SDKValidationError> {
+): SafeParseResult<PredictPropertyValueError, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ErrorT' from JSON`,
+    (x) => PredictPropertyValueError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PredictPropertyValueError' from JSON`,
   );
 }
 
@@ -299,7 +303,7 @@ export const PredictPropertyValueResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  error: z.lazy(() => ErrorT$inboundSchema),
+  error: z.lazy(() => PredictPropertyValueError$inboundSchema),
 });
 
 export function predictPropertyValueResponseBodyFromJSON(

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

@@ -0,0 +1,162 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+import {
+  NestedAggregation,
+  NestedAggregation$Outbound,
+  NestedAggregation$outboundSchema,
+} from "./nestedaggregation.js";
+import {
+  RangeDefinition,
+  RangeDefinition$Outbound,
+  RangeDefinition$outboundSchema,
+} from "./rangedefinition.js";
+
+export const Order = {
+  Asc: "asc",
+  Desc: "desc",
+} as const;
+export type Order = ClosedEnum<typeof Order>;
+
+/**
+ * Type of aggregation
+ */
+export const Type = {
+  Terms: "terms",
+  Range: "range",
+  Histogram: "histogram",
+  DateHistogram: "date_histogram",
+  Stats: "stats",
+  ExtendedStats: "extended_stats",
+  Min: "min",
+  Max: "max",
+  Avg: "avg",
+  Sum: "sum",
+  Count: "count",
+  Cardinality: "cardinality",
+  Percentiles: "percentiles",
+} as const;
+/**
+ * Type of aggregation
+ */
+export type Type = ClosedEnum<typeof Type>;
+
+export type AggregationInput = {
+  /**
+   * Nested sub-aggregations (max 10, up to 2 levels deep)
+   */
+  aggs?: Array<NestedAggregation> | undefined;
+  /**
+   * Calendar interval for date_histogram (1d, 1w, 1M, etc.)
+   */
+  calendarInterval?: string | undefined;
+  /**
+   * Field to aggregate on (must be in allowed field list)
+   */
+  field: string;
+  /**
+   * Fixed interval for date_histogram (1h, 90m, etc.)
+   */
+  fixedInterval?: string | undefined;
+  /**
+   * Date format for date_histogram
+   */
+  format?: string | undefined;
+  /**
+   * Interval for histogram aggregation
+   */
+  interval?: number | undefined;
+  /**
+   * Minimum document count for bucket to be returned
+   */
+  minDocCount?: number | undefined;
+  /**
+   * Unique name for this aggregation
+   */
+  name: string;
+  /**
+   * Sort order for terms buckets
+   */
+  order?: { [k: string]: Order } | undefined;
+  /**
+   * Percentiles to calculate
+   */
+  percents?: Array<number> | undefined;
+  /**
+   * Custom ranges for range aggregation
+   */
+  ranges?: Array<RangeDefinition> | undefined;
+  /**
+   * Max buckets for terms aggregation
+   */
+  size?: number | undefined;
+  /**
+   * Timezone for date_histogram
+   */
+  timeZone?: string | undefined;
+  /**
+   * Type of aggregation
+   */
+  type: Type;
+};
+
+/** @internal */
+export const Order$outboundSchema: z.ZodNativeEnum<typeof Order> = z.nativeEnum(
+  Order,
+);
+
+/** @internal */
+export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
+
+/** @internal */
+export type AggregationInput$Outbound = {
+  aggs?: Array<NestedAggregation$Outbound> | undefined;
+  calendarInterval?: string | undefined;
+  field: string;
+  fixedInterval?: string | undefined;
+  format?: string | undefined;
+  interval?: number | undefined;
+  minDocCount?: number | undefined;
+  name: string;
+  order?: { [k: string]: string } | undefined;
+  percents?: Array<number> | undefined;
+  ranges?: Array<RangeDefinition$Outbound> | undefined;
+  size?: number | undefined;
+  timeZone?: string | undefined;
+  type: string;
+};
+
+/** @internal */
+export const AggregationInput$outboundSchema: z.ZodType<
+  AggregationInput$Outbound,
+  z.ZodTypeDef,
+  AggregationInput
+> = z.object({
+  aggs: z.array(NestedAggregation$outboundSchema).optional(),
+  calendarInterval: z.string().optional(),
+  field: z.string(),
+  fixedInterval: z.string().optional(),
+  format: z.string().optional(),
+  interval: z.number().optional(),
+  minDocCount: z.number().int().optional(),
+  name: z.string(),
+  order: z.record(Order$outboundSchema).optional(),
+  percents: z.array(z.number()).optional(),
+  ranges: z.array(RangeDefinition$outboundSchema).optional(),
+  size: z.number().int().optional(),
+  timeZone: z.string().optional(),
+  type: Type$outboundSchema,
+});
+
+export function aggregationInputToJSON(
+  aggregationInput: AggregationInput,
+): string {
+  return JSON.stringify(
+    AggregationInput$outboundSchema.parse(aggregationInput),
+  );
+}

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

@@ -0,0 +1,107 @@
+/*
+ * 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";
+
+/**
+ * Quality tier based on similarity to subject
+ */
+export const Tier = {
+  Excellent: "excellent",
+  Good: "good",
+  Acceptable: "acceptable",
+  Excluded: "excluded",
+} as const;
+/**
+ * Quality tier based on similarity to subject
+ */
+export type Tier = ClosedEnum<typeof Tier>;
+
+/**
+ * Comparable property with tier assessment
+ */
+export type AnalysisComparable = {
+  /**
+   * Number of bathrooms
+   */
+  baths?: number | undefined;
+  /**
+   * Number of bedrooms
+   */
+  beds?: number | undefined;
+  /**
+   * Distance from subject property in metres
+   */
+  distanceMeters?: number | undefined;
+  /**
+   * Floor area in square metres
+   */
+  floorArea?: number | undefined;
+  /**
+   * Transaction price in GBP
+   */
+  price: number;
+  /**
+   * Unique property identifier
+   */
+  propertyId: string;
+  /**
+   * Property type
+   */
+  propertyType?: string | undefined;
+  /**
+   * Quality tier based on similarity to subject
+   */
+  tier: Tier;
+  /**
+   * Reasons for tier assignment
+   */
+  tierReasons: Array<string>;
+  /**
+   * Days since transaction
+   */
+  transactionAge?: number | undefined;
+  /**
+   * Weighting factor used in valuation
+   */
+  weight?: number | undefined;
+};
+
+/** @internal */
+export const Tier$inboundSchema: z.ZodNativeEnum<typeof Tier> = z.nativeEnum(
+  Tier,
+);
+
+/** @internal */
+export const AnalysisComparable$inboundSchema: z.ZodType<
+  AnalysisComparable,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  baths: z.number().int().optional(),
+  beds: z.number().int().optional(),
+  distanceMeters: z.number().optional(),
+  floorArea: z.number().optional(),
+  price: z.number(),
+  propertyId: z.string(),
+  propertyType: z.string().optional(),
+  tier: Tier$inboundSchema,
+  tierReasons: z.array(z.string()),
+  transactionAge: z.number().optional(),
+  weight: z.number().optional(),
+});
+
+export function analysisComparableFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalysisComparable, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalysisComparable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalysisComparable' from JSON`,
+  );
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * 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>;
+
+/**
+ * Request for detailed AVM analysis with comparables and history
+ */
+export type AVMAnalysisRequest = {
+  /**
+   * Number of months of historical data to include
+   */
+  historyMonths?: number | undefined;
+  /**
+   * Whether to include historical valuations
+   */
+  includeHistory?: boolean | undefined;
+  /**
+   * Property location identifier
+   */
+  locationId: string;
+  /**
+   * Type of transaction - sale or rental valuation
+   */
+  transactionType?: TransactionType | undefined;
+};
+
+/** @internal */
+export const TransactionType$outboundSchema: z.ZodNativeEnum<
+  typeof TransactionType
+> = z.nativeEnum(TransactionType);
+
+/** @internal */
+export type AVMAnalysisRequest$Outbound = {
+  historyMonths: number;
+  includeHistory: boolean;
+  locationId: string;
+  transactionType: string;
+};
+
+/** @internal */
+export const AVMAnalysisRequest$outboundSchema: z.ZodType<
+  AVMAnalysisRequest$Outbound,
+  z.ZodTypeDef,
+  AVMAnalysisRequest
+> = z.object({
+  historyMonths: z.number().int().default(12),
+  includeHistory: z.boolean().default(true),
+  locationId: z.string(),
+  transactionType: TransactionType$outboundSchema.default("sale"),
+});
+
+export function avmAnalysisRequestToJSON(
+  avmAnalysisRequest: AVMAnalysisRequest,
+): string {
+  return JSON.stringify(
+    AVMAnalysisRequest$outboundSchema.parse(avmAnalysisRequest),
+  );
+}