@vepler/sdk 2.33.0 → 2.37.0

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

@@ -6,17 +6,20 @@ 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 {
+  AggregationResult,
+  AggregationResult$inboundSchema,
+} from "./aggregationresult.js";
 
 export type PropertyAggregateResponse = {
   /**
-   * Aggregation results (structure varies by aggregation type)
+   * Aggregation results keyed by aggregation name
    */
-  aggregations: { [k: string]: any | null };
+  aggregations: { [k: string]: AggregationResult };
   /**
    * Calculated area size in km²
    */
   areaKm2: number;
-  success: boolean;
   /**
    * Total documents matching the query
    */
@@ -29,9 +32,8 @@ export const PropertyAggregateResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  aggregations: z.record(z.nullable(z.any())),
+  aggregations: z.record(AggregationResult$inboundSchema),
   areaKm2: z.number(),
-  success: z.boolean(),
   total: z.number(),
 });
 

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

@@ -25,6 +25,10 @@ import {
   PropertyAddress$inboundSchema,
 } from "./propertyaddress.js";
 import { PropertyTags, PropertyTags$inboundSchema } from "./propertytags.js";
+import {
+  ProsperityData,
+  ProsperityData$inboundSchema,
+} from "./prosperitydata.js";
 import {
   RefurbishmentData,
   RefurbishmentData$inboundSchema,
@@ -66,17 +70,17 @@ export const PropertyCategory = {
 } as const;
 export type PropertyCategory = OpenEnum<typeof PropertyCategory>;
 
-export type Two = {
+export type PropertyDataApi2 = {
   coordinates: Array<Array<Array<Array<number>>>>;
   type: "MultiPolygon";
 };
 
-export type One = {
+export type PropertyDataApi1 = {
   coordinates: Array<Array<Array<number>>>;
   type: "Polygon";
 };
 
-export type Boundary = One | Two;
+export type PropertyDataApiBoundary = PropertyDataApi1 | PropertyDataApi2;
 
 export const PropertyDataApiType = {
   Point: "Point",
@@ -84,7 +88,7 @@ export const PropertyDataApiType = {
 export type PropertyDataApiType = ClosedEnum<typeof PropertyDataApiType>;
 
 export type PropertyDataApiSpatial = {
-  boundary?: One | Two | undefined;
+  boundary?: PropertyDataApi1 | PropertyDataApi2 | undefined;
   coordinates?: Array<number> | undefined;
   type?: PropertyDataApiType | undefined;
 };
@@ -113,6 +117,7 @@ export type PropertyDataApi = {
   pricing?: PricingData | undefined;
   propertyCategory?: PropertyCategory | null | undefined;
   propertyId?: string | undefined;
+  prosperity?: ProsperityData | undefined;
   refurbishment?: RefurbishmentData | undefined;
   relationships?: Array<string> | undefined;
   roomDetails?: RoomDetails | undefined;
@@ -186,53 +191,62 @@ export const PropertyCategory$inboundSchema: z.ZodType<
 > = openEnums.inboundSchema(PropertyCategory);
 
 /** @internal */
-export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z
-  .object({
-    coordinates: z.array(z.array(z.array(z.array(z.number())))),
-    type: z.literal("MultiPolygon"),
-  });
+export const PropertyDataApi2$inboundSchema: z.ZodType<
+  PropertyDataApi2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinates: z.array(z.array(z.array(z.array(z.number())))),
+  type: z.literal("MultiPolygon"),
+});
 
-export function twoFromJSON(
+export function propertyDataApi2FromJSON(
   jsonString: string,
-): SafeParseResult<Two, SDKValidationError> {
+): SafeParseResult<PropertyDataApi2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Two$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Two' from JSON`,
+    (x) => PropertyDataApi2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyDataApi2' from JSON`,
   );
 }
 
 /** @internal */
-export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
-  .object({
-    coordinates: z.array(z.array(z.array(z.number()))),
-    type: z.literal("Polygon"),
-  });
+export const PropertyDataApi1$inboundSchema: z.ZodType<
+  PropertyDataApi1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinates: z.array(z.array(z.array(z.number()))),
+  type: z.literal("Polygon"),
+});
 
-export function oneFromJSON(
+export function propertyDataApi1FromJSON(
   jsonString: string,
-): SafeParseResult<One, SDKValidationError> {
+): SafeParseResult<PropertyDataApi1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => One$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'One' from JSON`,
+    (x) => PropertyDataApi1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyDataApi1' from JSON`,
   );
 }
 
 /** @internal */
-export const Boundary$inboundSchema: z.ZodType<
-  Boundary,
+export const PropertyDataApiBoundary$inboundSchema: z.ZodType<
+  PropertyDataApiBoundary,
   z.ZodTypeDef,
   unknown
-> = z.union([z.lazy(() => One$inboundSchema), z.lazy(() => Two$inboundSchema)]);
+> = z.union([
+  z.lazy(() => PropertyDataApi1$inboundSchema),
+  z.lazy(() => PropertyDataApi2$inboundSchema),
+]);
 
-export function boundaryFromJSON(
+export function propertyDataApiBoundaryFromJSON(
   jsonString: string,
-): SafeParseResult<Boundary, SDKValidationError> {
+): SafeParseResult<PropertyDataApiBoundary, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Boundary$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Boundary' from JSON`,
+    (x) => PropertyDataApiBoundary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyDataApiBoundary' from JSON`,
   );
 }
 
@@ -248,8 +262,8 @@ export const PropertyDataApiSpatial$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   boundary: z.union([
-    z.lazy(() => One$inboundSchema),
-    z.lazy(() => Two$inboundSchema),
+    z.lazy(() => PropertyDataApi1$inboundSchema),
+    z.lazy(() => PropertyDataApi2$inboundSchema),
   ]).optional(),
   coordinates: z.array(z.number()).optional(),
   type: PropertyDataApiType$inboundSchema.optional(),
@@ -292,6 +306,7 @@ export const PropertyDataApi$inboundSchema: z.ZodType<
   pricing: PricingData$inboundSchema.optional(),
   propertyCategory: z.nullable(PropertyCategory$inboundSchema).optional(),
   propertyId: z.string().optional(),
+  prosperity: ProsperityData$inboundSchema.optional(),
   refurbishment: RefurbishmentData$inboundSchema.optional(),
   relationships: z.array(z.string()).optional(),
   roomDetails: RoomDetails$inboundSchema.optional(),

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

@@ -3,7 +3,9 @@
  */
 
 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 {
@@ -11,42 +13,66 @@ import {
   PropertyDataApi$inboundSchema,
 } from "./propertydataapi.js";
 
+/**
+ * Object type identifier
+ */
+export const PropertyListResponseObject = {
+  List: "list",
+} as const;
+/**
+ * Object type identifier
+ */
+export type PropertyListResponseObject = ClosedEnum<
+  typeof PropertyListResponseObject
+>;
+
+/**
+ * Paginated list response
+ */
 export type PropertyListResponse = {
   /**
-   * Indicates if more results are available
+   * Array of items
    */
-  hasMore?: boolean | undefined;
+  data: Array<PropertyDataApi>;
   /**
-   * Offset to use for next page of results
+   * Whether more items exist
    */
-  nextOffset?: number | undefined;
+  hasMore: boolean;
   /**
-   * Array of property data objects
+   * Object type identifier
    */
-  result: Array<PropertyDataApi>;
+  object: PropertyListResponseObject;
   /**
-   * Number of properties returned in this response
+   * Total number of items available
    */
-  size: number;
-  success: boolean;
+  totalCount?: number | undefined;
   /**
-   * Total number of properties matching the query
+   * URL of the request
    */
-  totalSize: number;
+  url: string;
 };
 
+/** @internal */
+export const PropertyListResponseObject$inboundSchema: z.ZodNativeEnum<
+  typeof PropertyListResponseObject
+> = z.nativeEnum(PropertyListResponseObject);
+
 /** @internal */
 export const PropertyListResponse$inboundSchema: z.ZodType<
   PropertyListResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  hasMore: z.boolean().optional(),
-  nextOffset: z.number().optional(),
-  result: z.array(PropertyDataApi$inboundSchema),
-  size: z.number(),
-  success: z.boolean(),
-  totalSize: z.number(),
+  data: z.array(PropertyDataApi$inboundSchema),
+  has_more: z.boolean(),
+  object: PropertyListResponseObject$inboundSchema,
+  total_count: z.number().optional(),
+  url: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+    "total_count": "totalCount",
+  });
 });
 
 export function propertyListResponseFromJSON(

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

@@ -14,7 +14,7 @@ export type PropertyPointAreaFilterType = ClosedEnum<
 
 export type PropertyPointAreaFilter = {
   /**
-   * [latitude, longitude] coordinates
+   * [latitude, longitude] coordinates in WGS84 decimal degrees. Note: this uses [lat, lng] order (not GeoJSON [lng, lat]). Example: [51.5074, -0.1278] for central London.
    */
   coordinates: Array<number>;
   /**

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

@@ -14,7 +14,7 @@ export type PropertyPolygonAreaFilterType = ClosedEnum<
 
 export type PropertyPolygonAreaFilter = {
   /**
-   * Array of polygon coordinates
+   * Polygon ring coordinates as [latitude, longitude] pairs. Outer ring defines the boundary; additional rings define holes. First and last coordinate must be identical to close the ring. Note: uses [lat, lng] order (not GeoJSON [lng, lat]).
    */
   coordinates: Array<Array<Array<number>>>;
   type: PropertyPolygonAreaFilterType;

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

@@ -26,7 +26,7 @@ export const Comparator = {
  */
 export type Comparator = ClosedEnum<typeof Comparator>;
 
-export type Four = string | number | boolean;
+export type PropertyQueryCondition4 = string | number | boolean;
 
 /**
  * Value to compare against
@@ -57,14 +57,21 @@ export const Comparator$outboundSchema: z.ZodNativeEnum<typeof Comparator> = z
   .nativeEnum(Comparator);
 
 /** @internal */
-export type Four$Outbound = string | number | boolean;
+export type PropertyQueryCondition4$Outbound = string | number | boolean;
 
 /** @internal */
-export const Four$outboundSchema: z.ZodType<Four$Outbound, z.ZodTypeDef, Four> =
-  z.union([z.string(), z.number(), z.boolean()]);
+export const PropertyQueryCondition4$outboundSchema: z.ZodType<
+  PropertyQueryCondition4$Outbound,
+  z.ZodTypeDef,
+  PropertyQueryCondition4
+> = z.union([z.string(), z.number(), z.boolean()]);
 
-export function fourToJSON(four: Four): string {
-  return JSON.stringify(Four$outboundSchema.parse(four));
+export function propertyQueryCondition4ToJSON(
+  propertyQueryCondition4: PropertyQueryCondition4,
+): string {
+  return JSON.stringify(
+    PropertyQueryCondition4$outboundSchema.parse(propertyQueryCondition4),
+  );
 }
 
 /** @internal */

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

@@ -23,7 +23,7 @@ export type Attributes = string | Array<string>;
 /**
  * Field to sort by (whitelisted fields only)
  */
-export const Field = {
+export const PropertyQueryRequestField = {
   MarketStatusLastOTM: "marketStatus.lastOTM",
   MarketStatusLastOTMRent: "marketStatus.lastOTMRent",
   MarketStatusBackOTM: "marketStatus.backOTM",
@@ -47,7 +47,9 @@ export const Field = {
 /**
  * Field to sort by (whitelisted fields only)
  */
-export type Field = ClosedEnum<typeof Field>;
+export type PropertyQueryRequestField = ClosedEnum<
+  typeof PropertyQueryRequestField
+>;
 
 /**
  * How to handle missing values
@@ -94,7 +96,7 @@ export type Sort = {
   /**
    * Field to sort by (whitelisted fields only)
    */
-  field: Field;
+  field: PropertyQueryRequestField;
   /**
    * How to handle missing values
    */
@@ -155,9 +157,9 @@ export function attributesToJSON(attributes: Attributes): string {
 }
 
 /** @internal */
-export const Field$outboundSchema: z.ZodNativeEnum<typeof Field> = z.nativeEnum(
-  Field,
-);
+export const PropertyQueryRequestField$outboundSchema: z.ZodNativeEnum<
+  typeof PropertyQueryRequestField
+> = z.nativeEnum(PropertyQueryRequestField);
 
 /** @internal */
 export const Missing$outboundSchema: z.ZodNativeEnum<typeof Missing> = z
@@ -184,7 +186,7 @@ export type Sort$Outbound = {
 /** @internal */
 export const Sort$outboundSchema: z.ZodType<Sort$Outbound, z.ZodTypeDef, Sort> =
   z.object({
-    field: Field$outboundSchema,
+    field: PropertyQueryRequestField$outboundSchema,
     missing: Missing$outboundSchema.optional(),
     mode: Mode$outboundSchema.optional(),
     order: PropertyQueryRequestOrder$outboundSchema,

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

@@ -0,0 +1,178 @@
+/*
+ * 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 Employment = {
+  /**
+   * Dimension score 0-100
+   */
+  score?: number | undefined;
+};
+
+export type Housing = {
+  /**
+   * Dimension score 0-100
+   */
+  score?: number | undefined;
+};
+
+export type Income = {
+  /**
+   * Dimension score 0-100
+   */
+  score?: number | undefined;
+};
+
+export type LivingStandards = {
+  /**
+   * Dimension score 0-100
+   */
+  score?: number | undefined;
+};
+
+export type Dimensions = {
+  employment?: Employment | undefined;
+  housing?: Housing | undefined;
+  income?: Income | undefined;
+  livingStandards?: LivingStandards | undefined;
+};
+
+export type ProsperityData = {
+  /**
+   * National decile 1-10
+   */
+  decile?: number | undefined;
+  dimensions?: Dimensions | undefined;
+  /**
+   * National percentile 1-100
+   */
+  percentile?: number | undefined;
+  /**
+   * Overall prosperity score 0-100
+   */
+  score?: number | undefined;
+  /**
+   * Dataset version e.g. 2026.1
+   */
+  version?: string | undefined;
+};
+
+/** @internal */
+export const Employment$inboundSchema: z.ZodType<
+  Employment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  score: z.number().optional(),
+});
+
+export function employmentFromJSON(
+  jsonString: string,
+): SafeParseResult<Employment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Employment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Employment' from JSON`,
+  );
+}
+
+/** @internal */
+export const Housing$inboundSchema: z.ZodType<Housing, z.ZodTypeDef, unknown> =
+  z.object({
+    score: z.number().optional(),
+  });
+
+export function housingFromJSON(
+  jsonString: string,
+): SafeParseResult<Housing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Housing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Housing' from JSON`,
+  );
+}
+
+/** @internal */
+export const Income$inboundSchema: z.ZodType<Income, z.ZodTypeDef, unknown> = z
+  .object({
+    score: z.number().optional(),
+  });
+
+export function incomeFromJSON(
+  jsonString: string,
+): SafeParseResult<Income, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Income$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Income' from JSON`,
+  );
+}
+
+/** @internal */
+export const LivingStandards$inboundSchema: z.ZodType<
+  LivingStandards,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  score: z.number().optional(),
+});
+
+export function livingStandardsFromJSON(
+  jsonString: string,
+): SafeParseResult<LivingStandards, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LivingStandards$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LivingStandards' from JSON`,
+  );
+}
+
+/** @internal */
+export const Dimensions$inboundSchema: z.ZodType<
+  Dimensions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  employment: z.lazy(() => Employment$inboundSchema).optional(),
+  housing: z.lazy(() => Housing$inboundSchema).optional(),
+  income: z.lazy(() => Income$inboundSchema).optional(),
+  livingStandards: z.lazy(() => LivingStandards$inboundSchema).optional(),
+});
+
+export function dimensionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Dimensions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Dimensions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Dimensions' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProsperityData$inboundSchema: z.ZodType<
+  ProsperityData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  decile: z.number().int().optional(),
+  dimensions: z.lazy(() => Dimensions$inboundSchema).optional(),
+  percentile: z.number().int().optional(),
+  score: z.number().optional(),
+  version: z.string().optional(),
+});
+
+export function prosperityDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ProsperityData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProsperityData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProsperityData' from JSON`,
+  );
+}