@vepler/sdk 2.28.0 → 2.30.0

package/src/sdk/avm.ts

@@ -6,7 +6,6 @@ import { avmGetValuationAnalysis } from "../funcs/avmGetValuationAnalysis.js";
 import { avmPredictPropertyValue } from "../funcs/avmPredictPropertyValue.js";
 import { avmPredictPropertyValueByLocation } from "../funcs/avmPredictPropertyValueByLocation.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
-import * as operations from "./models/operations/index.js";
 import * as shared from "./models/shared/index.js";
 import { unwrapAsync } from "./types/fp.js";
 
@@ -20,7 +19,7 @@ export class Avm extends ClientSDK {
   async getValuationAnalysis(
     request: shared.AVMAnalysisRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetValuationAnalysisResponse> {
+  ): Promise<shared.AVMAnalysisResponse> {
     return unwrapAsync(avmGetValuationAnalysis(
       this,
       request,
@@ -37,7 +36,7 @@ export class Avm extends ClientSDK {
   async predictPropertyValue(
     request: shared.AVMPredictRequest,
     options?: RequestOptions,
-  ): Promise<operations.PredictPropertyValueResponse> {
+  ): Promise<shared.AVMPredictResponse> {
     return unwrapAsync(avmPredictPropertyValue(
       this,
       request,
@@ -54,7 +53,7 @@ export class Avm extends ClientSDK {
   async predictPropertyValueByLocation(
     request: shared.AVMPredictByLocationRequest,
     options?: RequestOptions,
-  ): Promise<operations.PredictPropertyValueByLocationResponse> {
+  ): Promise<shared.AVMPredictResponse> {
     return unwrapAsync(avmPredictPropertyValueByLocation(
       this,
       request,

package/src/sdk/connectivity.ts

@@ -17,7 +17,7 @@ export class Connectivity extends ClientSDK {
   async getConnectivityScores(
     request: operations.GetConnectivityScoresRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetConnectivityScoresResponse> {
+  ): Promise<operations.GetConnectivityScoresResponseBody> {
     return unwrapAsync(connectivityGetConnectivityScores(
       this,
       request,

package/src/sdk/councils.ts

@@ -6,6 +6,7 @@ import { councilsGet } from "../funcs/councilsGet.js";
 import { councilsList } from "../funcs/councilsList.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "./models/operations/index.js";
+import * as shared from "./models/shared/index.js";
 import { unwrapAsync } from "./types/fp.js";
 
 export class Councils extends ClientSDK {
@@ -18,7 +19,7 @@ export class Councils extends ClientSDK {
   async get(
     request: operations.GetCouncilByProviderIdRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetCouncilByProviderIdResponse> {
+  ): Promise<shared.Council> {
     return unwrapAsync(councilsGet(
       this,
       request,
@@ -35,7 +36,7 @@ export class Councils extends ClientSDK {
   async list(
     request?: operations.ListCouncilsRequest | undefined,
     options?: RequestOptions,
-  ): Promise<operations.ListCouncilsResponse> {
+  ): Promise<shared.CouncilListResponse> {
     return unwrapAsync(councilsList(
       this,
       request,

package/src/sdk/epc.ts

@@ -17,7 +17,7 @@ export class Epc extends ClientSDK {
   async getByLocationId(
     request: operations.GetEpcByLocationIdRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetEpcByLocationIdResponse> {
+  ): Promise<operations.GetEpcByLocationIdResponseBody> {
     return unwrapAsync(epcGetByLocationId(
       this,
       request,

package/src/sdk/listings.ts

@@ -21,7 +21,7 @@ export class Listings extends ClientSDK {
   async getListingById(
     request: operations.GetListingByIdRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetListingByIdResponse> {
+  ): Promise<operations.GetListingByIdResponseBody> {
     return unwrapAsync(listingsGetListingById(
       this,
       request,
@@ -38,7 +38,7 @@ export class Listings extends ClientSDK {
   async getListingBySource(
     request: operations.GetListingBySourceRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetListingBySourceResponse> {
+  ): Promise<operations.GetListingBySourceResponseBody> {
     return unwrapAsync(listingsGetListingBySource(
       this,
       request,
@@ -55,7 +55,7 @@ export class Listings extends ClientSDK {
   async getListingsByLocation(
     request: operations.GetListingsByLocationRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetListingsByLocationResponse> {
+  ): Promise<operations.GetListingsByLocationResponseBody> {
     return unwrapAsync(listingsGetListingsByLocation(
       this,
       request,
@@ -72,7 +72,7 @@ export class Listings extends ClientSDK {
   async queryListings(
     request?: operations.QueryListingsRequestBody | undefined,
     options?: RequestOptions,
-  ): Promise<operations.QueryListingsResponse> {
+  ): Promise<operations.QueryListingsResponseBody> {
     return unwrapAsync(listingsQueryListings(
       this,
       request,
@@ -89,7 +89,7 @@ export class Listings extends ClientSDK {
   async queryListingsBySource(
     request?: operations.QueryListingsBySourceRequestBody | undefined,
     options?: RequestOptions,
-  ): Promise<operations.QueryListingsBySourceResponse> {
+  ): Promise<operations.QueryListingsBySourceResponseBody> {
     return unwrapAsync(listingsQueryListingsBySource(
       this,
       request,

package/src/sdk/metrics.ts

@@ -17,7 +17,7 @@ export class Metrics extends ClientSDK {
   async getMetricValues(
     request?: operations.GetMetricValuesRequest | undefined,
     options?: RequestOptions,
-  ): Promise<operations.GetMetricValuesResponse> {
+  ): Promise<operations.GetMetricValuesResponseBody> {
     return unwrapAsync(metricsGetMetricValues(
       this,
       request,

package/src/sdk/models/{operations → errors}/aggregateproperties.ts

@@ -5,10 +5,11 @@
 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 * as openEnums from "../../types/enums.js";
+import { OpenEnum } 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";
+import { SDKBaseError } from "./sdkbaseerror.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
 
 /**
  * Error type category
@@ -22,7 +23,7 @@ export const AggregatePropertiesPropertyType = {
 /**
  * Error type category
  */
-export type AggregatePropertiesPropertyType = ClosedEnum<
+export type AggregatePropertiesPropertyType = OpenEnum<
   typeof AggregatePropertiesPropertyType
 >;
 
@@ -52,10 +53,33 @@ export type AggregatePropertiesPropertyError = {
 /**
  * Error response
  */
-export type AggregatePropertiesPropertyResponseBody = {
+export type AggregatePropertiesPropertyResponseBodyData = {
   error: AggregatePropertiesPropertyError;
 };
 
+/**
+ * Error response
+ */
+export class AggregatePropertiesPropertyResponseBody extends SDKBaseError {
+  error: AggregatePropertiesPropertyError;
+
+  /** The original data that was passed to this error instance. */
+  data$: AggregatePropertiesPropertyResponseBodyData;
+
+  constructor(
+    err: AggregatePropertiesPropertyResponseBodyData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "AggregatePropertiesPropertyResponseBody";
+  }
+}
+
 /**
  * Error type category
  */
@@ -68,9 +92,7 @@ export const AggregatePropertiesType = {
 /**
  * Error type category
  */
-export type AggregatePropertiesType = ClosedEnum<
-  typeof AggregatePropertiesType
->;
+export type AggregatePropertiesType = OpenEnum<typeof AggregatePropertiesType>;
 
 export type AggregatePropertiesError = {
   /**
@@ -98,19 +120,39 @@ export type AggregatePropertiesError = {
 /**
  * Error response
  */
-export type AggregatePropertiesResponseBody = {
+export type AggregatePropertiesResponseBodyData = {
   error: AggregatePropertiesError;
 };
 
-export type AggregatePropertiesResponse =
-  | shared.PropertyAggregateResponse
-  | AggregatePropertiesResponseBody
-  | AggregatePropertiesPropertyResponseBody;
+/**
+ * Error response
+ */
+export class AggregatePropertiesResponseBody extends SDKBaseError {
+  error: AggregatePropertiesError;
+
+  /** The original data that was passed to this error instance. */
+  data$: AggregatePropertiesResponseBodyData;
+
+  constructor(
+    err: AggregatePropertiesResponseBodyData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "AggregatePropertiesResponseBody";
+  }
+}
 
 /** @internal */
-export const AggregatePropertiesPropertyType$inboundSchema: z.ZodNativeEnum<
-  typeof AggregatePropertiesPropertyType
-> = z.nativeEnum(AggregatePropertiesPropertyType);
+export const AggregatePropertiesPropertyType$inboundSchema: z.ZodType<
+  AggregatePropertiesPropertyType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(AggregatePropertiesPropertyType);
 
 /** @internal */
 export const AggregatePropertiesPropertyError$inboundSchema: z.ZodType<
@@ -146,28 +188,24 @@ export const AggregatePropertiesPropertyResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   error: z.lazy(() => AggregatePropertiesPropertyError$inboundSchema),
-});
-
-export function aggregatePropertiesPropertyResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  AggregatePropertiesPropertyResponseBody,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      AggregatePropertiesPropertyResponseBody$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'AggregatePropertiesPropertyResponseBody' from JSON`,
-  );
-}
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new AggregatePropertiesPropertyResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
 
 /** @internal */
-export const AggregatePropertiesType$inboundSchema: z.ZodNativeEnum<
-  typeof AggregatePropertiesType
-> = z.nativeEnum(AggregatePropertiesType);
+export const AggregatePropertiesType$inboundSchema: z.ZodType<
+  AggregatePropertiesType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(AggregatePropertiesType);
 
 /** @internal */
 export const AggregatePropertiesError$inboundSchema: z.ZodType<
@@ -203,35 +241,14 @@ export const AggregatePropertiesResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   error: z.lazy(() => AggregatePropertiesError$inboundSchema),
-});
-
-export function aggregatePropertiesResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<AggregatePropertiesResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AggregatePropertiesResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AggregatePropertiesResponseBody' from JSON`,
-  );
-}
-
-/** @internal */
-export const AggregatePropertiesResponse$inboundSchema: z.ZodType<
-  AggregatePropertiesResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  shared.PropertyAggregateResponse$inboundSchema,
-  z.lazy(() => AggregatePropertiesResponseBody$inboundSchema),
-  z.lazy(() => AggregatePropertiesPropertyResponseBody$inboundSchema),
-]);
-
-export function aggregatePropertiesResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<AggregatePropertiesResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AggregatePropertiesResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AggregatePropertiesResponse' from JSON`,
-  );
-}
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new AggregatePropertiesResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });

package/src/sdk/models/errors/councilerrorresponse.ts

@@ -0,0 +1,92 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKBaseError } from "./sdkbaseerror.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
+
+export const Type = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+export type Type = OpenEnum<typeof Type>;
+
+export type ErrorT = {
+  code?: string | undefined;
+  message: string;
+  param?: string | undefined;
+  type: Type;
+};
+
+export type CouncilErrorResponseData = {
+  error: ErrorT;
+};
+
+export class CouncilErrorResponse extends SDKBaseError {
+  error: ErrorT;
+
+  /** The original data that was passed to this error instance. */
+  data$: CouncilErrorResponseData;
+
+  constructor(
+    err: CouncilErrorResponseData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+
+    this.name = "CouncilErrorResponse";
+  }
+}
+
+/** @internal */
+export const Type$inboundSchema: z.ZodType<Type, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Type);
+
+/** @internal */
+export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
+  .object({
+    code: z.string().optional(),
+    message: z.string(),
+    param: z.string().optional(),
+    type: Type$inboundSchema,
+  });
+
+export function errorFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
+  );
+}
+
+/** @internal */
+export const CouncilErrorResponse$inboundSchema: z.ZodType<
+  CouncilErrorResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => ErrorT$inboundSchema),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new CouncilErrorResponse(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });

package/src/sdk/models/errors/getareasbyfieldandids.ts

@@ -0,0 +1,178 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { SDKBaseError } from "./sdkbaseerror.js";
+
+/**
+ * Error response format for failed requests
+ */
+export type GetAreasByFieldAndIdsAreasResponseBodyData = {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * Detailed error information for debugging
+   */
+  details?: string | undefined;
+  /**
+   * High-level error category or message
+   */
+  error: string;
+  /**
+   * Always false for error responses
+   */
+  success: boolean;
+};
+
+/**
+ * Error response format for failed requests
+ */
+export class GetAreasByFieldAndIdsAreasResponseBody extends SDKBaseError {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * Detailed error information for debugging
+   */
+  details?: string | undefined;
+  /**
+   * High-level error category or message
+   */
+  error: string;
+  /**
+   * Always false for error responses
+   */
+  success: boolean;
+
+  /** The original data that was passed to this error instance. */
+  data$: GetAreasByFieldAndIdsAreasResponseBodyData;
+
+  constructor(
+    err: GetAreasByFieldAndIdsAreasResponseBodyData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = "message" in err && typeof err.message === "string"
+      ? err.message
+      : `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    if (err.code != null) this.code = err.code;
+    if (err.details != null) this.details = err.details;
+    this.error = err.error;
+    this.success = err.success;
+
+    this.name = "GetAreasByFieldAndIdsAreasResponseBody";
+  }
+}
+
+/**
+ * Error response format for failed requests
+ */
+export type GetAreasByFieldAndIdsResponseBodyData = {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * Detailed error information for debugging
+   */
+  details?: string | undefined;
+  /**
+   * High-level error category or message
+   */
+  error: string;
+  /**
+   * Always false for error responses
+   */
+  success: boolean;
+};
+
+/**
+ * Error response format for failed requests
+ */
+export class GetAreasByFieldAndIdsResponseBody extends SDKBaseError {
+  /**
+   * Machine-readable error code
+   */
+  code?: string | undefined;
+  /**
+   * Detailed error information for debugging
+   */
+  details?: string | undefined;
+  /**
+   * High-level error category or message
+   */
+  error: string;
+  /**
+   * Always false for error responses
+   */
+  success: boolean;
+
+  /** The original data that was passed to this error instance. */
+  data$: GetAreasByFieldAndIdsResponseBodyData;
+
+  constructor(
+    err: GetAreasByFieldAndIdsResponseBodyData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = "message" in err && typeof err.message === "string"
+      ? err.message
+      : `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    if (err.code != null) this.code = err.code;
+    if (err.details != null) this.details = err.details;
+    this.error = err.error;
+    this.success = err.success;
+
+    this.name = "GetAreasByFieldAndIdsResponseBody";
+  }
+}
+
+/** @internal */
+export const GetAreasByFieldAndIdsAreasResponseBody$inboundSchema: z.ZodType<
+  GetAreasByFieldAndIdsAreasResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  details: z.string().optional(),
+  error: z.string(),
+  success: z.boolean(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new GetAreasByFieldAndIdsAreasResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export const GetAreasByFieldAndIdsResponseBody$inboundSchema: z.ZodType<
+  GetAreasByFieldAndIdsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  details: z.string().optional(),
+  error: z.string(),
+  success: z.boolean(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new GetAreasByFieldAndIdsResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });