@vepler/sdk 2.24.2 → 2.29.0

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

@@ -22,30 +22,6 @@ export type SearchSchoolsWithinRequest = {
   west: string;
 };
 
-export const SearchSchoolsWithinType = {
-  ApiError: "api_error",
-  InvalidRequestError: "invalid_request_error",
-  AuthenticationError: "authentication_error",
-  RateLimitError: "rate_limit_error",
-} as const;
-export type SearchSchoolsWithinType = ClosedEnum<
-  typeof SearchSchoolsWithinType
->;
-
-export type SearchSchoolsWithinError = {
-  code?: string | undefined;
-  message: string;
-  param?: string | undefined;
-  type: SearchSchoolsWithinType;
-};
-
-/**
- * Error response
- */
-export type SearchSchoolsWithinSchoolsResponseBody = {
-  error: SearchSchoolsWithinError;
-};
-
 export const SearchSchoolsWithinObject = {
   List: "list",
 } as const;
@@ -64,10 +40,6 @@ export type SearchSchoolsWithinResponseBody = {
   url: string;
 };
 
-export type SearchSchoolsWithinResponse =
-  | SearchSchoolsWithinResponseBody
-  | SearchSchoolsWithinSchoolsResponseBody;
-
 /** @internal */
 export type SearchSchoolsWithinRequest$Outbound = {
   east: string;
@@ -106,53 +78,6 @@ export function searchSchoolsWithinRequestToJSON(
   );
 }
 
-/** @internal */
-export const SearchSchoolsWithinType$inboundSchema: z.ZodNativeEnum<
-  typeof SearchSchoolsWithinType
-> = z.nativeEnum(SearchSchoolsWithinType);
-
-/** @internal */
-export const SearchSchoolsWithinError$inboundSchema: z.ZodType<
-  SearchSchoolsWithinError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string().optional(),
-  message: z.string(),
-  param: z.string().optional(),
-  type: SearchSchoolsWithinType$inboundSchema,
-});
-
-export function searchSchoolsWithinErrorFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSchoolsWithinError, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSchoolsWithinError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSchoolsWithinError' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchSchoolsWithinSchoolsResponseBody$inboundSchema: z.ZodType<
-  SearchSchoolsWithinSchoolsResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => SearchSchoolsWithinError$inboundSchema),
-});
-
-export function searchSchoolsWithinSchoolsResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSchoolsWithinSchoolsResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      SearchSchoolsWithinSchoolsResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSchoolsWithinSchoolsResponseBody' from JSON`,
-  );
-}
-
 /** @internal */
 export const SearchSchoolsWithinObject$inboundSchema: z.ZodNativeEnum<
   typeof SearchSchoolsWithinObject
@@ -185,23 +110,3 @@ export function searchSchoolsWithinResponseBodyFromJSON(
     `Failed to parse 'SearchSchoolsWithinResponseBody' from JSON`,
   );
 }
-
-/** @internal */
-export const SearchSchoolsWithinResponse$inboundSchema: z.ZodType<
-  SearchSchoolsWithinResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => SearchSchoolsWithinResponseBody$inboundSchema),
-  z.lazy(() => SearchSchoolsWithinSchoolsResponseBody$inboundSchema),
-]);
-
-export function searchSchoolsWithinResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSchoolsWithinResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSchoolsWithinResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSchoolsWithinResponse' from JSON`,
-  );
-}

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

@@ -3,12 +3,6 @@
  */
 
 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";
 
 export type SearchSuggestRequest = {
   /**
@@ -29,101 +23,6 @@ export type SearchSuggestRequest = {
   source?: string | undefined;
 };
 
-/**
- * Error type category
- */
-export const SearchSuggestSearchType = {
-  ApiError: "api_error",
-  InvalidRequestError: "invalid_request_error",
-  AuthenticationError: "authentication_error",
-  RateLimitError: "rate_limit_error",
-} as const;
-/**
- * Error type category
- */
-export type SearchSuggestSearchType = ClosedEnum<
-  typeof SearchSuggestSearchType
->;
-
-export type SearchSuggestSearchError = {
-  /**
-   * 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: SearchSuggestSearchType;
-};
-
-/**
- * Error response
- */
-export type SearchSuggestSearchResponseBody = {
-  error: SearchSuggestSearchError;
-};
-
-/**
- * Error type category
- */
-export const SearchSuggestType = {
-  ApiError: "api_error",
-  InvalidRequestError: "invalid_request_error",
-  AuthenticationError: "authentication_error",
-  RateLimitError: "rate_limit_error",
-} as const;
-/**
- * Error type category
- */
-export type SearchSuggestType = ClosedEnum<typeof SearchSuggestType>;
-
-export type SearchSuggestError = {
-  /**
-   * 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: SearchSuggestType;
-};
-
-/**
- * Error response
- */
-export type SearchSuggestResponseBody = {
-  error: SearchSuggestError;
-};
-
-export type SearchSuggestResponse =
-  | shared.SearchResponse
-  | SearchSuggestResponseBody
-  | SearchSuggestSearchResponseBody;
-
 /** @internal */
 export type SearchSuggestRequest$Outbound = {
   limit?: string | undefined;
@@ -151,126 +50,3 @@ export function searchSuggestRequestToJSON(
     SearchSuggestRequest$outboundSchema.parse(searchSuggestRequest),
   );
 }
-
-/** @internal */
-export const SearchSuggestSearchType$inboundSchema: z.ZodNativeEnum<
-  typeof SearchSuggestSearchType
-> = z.nativeEnum(SearchSuggestSearchType);
-
-/** @internal */
-export const SearchSuggestSearchError$inboundSchema: z.ZodType<
-  SearchSuggestSearchError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string().optional(),
-  doc_url: z.string().optional(),
-  message: z.string(),
-  param: z.string().optional(),
-  type: SearchSuggestSearchType$inboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    "doc_url": "docUrl",
-  });
-});
-
-export function searchSuggestSearchErrorFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSuggestSearchError, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSuggestSearchError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSuggestSearchError' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchSuggestSearchResponseBody$inboundSchema: z.ZodType<
-  SearchSuggestSearchResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => SearchSuggestSearchError$inboundSchema),
-});
-
-export function searchSuggestSearchResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSuggestSearchResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSuggestSearchResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSuggestSearchResponseBody' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchSuggestType$inboundSchema: z.ZodNativeEnum<
-  typeof SearchSuggestType
-> = z.nativeEnum(SearchSuggestType);
-
-/** @internal */
-export const SearchSuggestError$inboundSchema: z.ZodType<
-  SearchSuggestError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string().optional(),
-  doc_url: z.string().optional(),
-  message: z.string(),
-  param: z.string().optional(),
-  type: SearchSuggestType$inboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    "doc_url": "docUrl",
-  });
-});
-
-export function searchSuggestErrorFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSuggestError, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSuggestError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSuggestError' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchSuggestResponseBody$inboundSchema: z.ZodType<
-  SearchSuggestResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  error: z.lazy(() => SearchSuggestError$inboundSchema),
-});
-
-export function searchSuggestResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSuggestResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSuggestResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSuggestResponseBody' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchSuggestResponse$inboundSchema: z.ZodType<
-  SearchSuggestResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  shared.SearchResponse$inboundSchema,
-  z.lazy(() => SearchSuggestResponseBody$inboundSchema),
-  z.lazy(() => SearchSuggestSearchResponseBody$inboundSchema),
-]);
-
-export function searchSuggestResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchSuggestResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchSuggestResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchSuggestResponse' from JSON`,
-  );
-}

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),
+  );
+}