@vepler/sdk 2.28.0 → 2.30.0

package/src/sdk/models/{operations → errors}/searchstreets.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 SearchStreetsStreetsResponseType = {
 /**
  * Error type category
  */
-export type SearchStreetsStreetsResponseType = ClosedEnum<
+export type SearchStreetsStreetsResponseType = OpenEnum<
   typeof SearchStreetsStreetsResponseType
 >;
 
@@ -52,10 +53,33 @@ export type SearchStreetsStreetsResponseError = {
 /**
  * Error response
  */
-export type SearchStreetsStreetsResponseResponseBody = {
+export type SearchStreetsStreetsResponseResponseBodyData = {
   error: SearchStreetsStreetsResponseError;
 };
 
+/**
+ * Error response
+ */
+export class SearchStreetsStreetsResponseResponseBody extends SDKBaseError {
+  error: SearchStreetsStreetsResponseError;
+
+  /** The original data that was passed to this error instance. */
+  data$: SearchStreetsStreetsResponseResponseBodyData;
+
+  constructor(
+    err: SearchStreetsStreetsResponseResponseBodyData,
+    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 = "SearchStreetsStreetsResponseResponseBody";
+  }
+}
+
 /**
  * Error type category
  */
@@ -68,7 +92,7 @@ export const SearchStreetsStreetsType = {
 /**
  * Error type category
  */
-export type SearchStreetsStreetsType = ClosedEnum<
+export type SearchStreetsStreetsType = OpenEnum<
   typeof SearchStreetsStreetsType
 >;
 
@@ -98,10 +122,33 @@ export type SearchStreetsStreetsError = {
 /**
  * Error response
  */
-export type SearchStreetsStreetsResponseBody = {
+export type SearchStreetsStreetsResponseBodyData = {
   error: SearchStreetsStreetsError;
 };
 
+/**
+ * Error response
+ */
+export class SearchStreetsStreetsResponseBody extends SDKBaseError {
+  error: SearchStreetsStreetsError;
+
+  /** The original data that was passed to this error instance. */
+  data$: SearchStreetsStreetsResponseBodyData;
+
+  constructor(
+    err: SearchStreetsStreetsResponseBodyData,
+    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 = "SearchStreetsStreetsResponseBody";
+  }
+}
+
 /**
  * Error type category
  */
@@ -114,7 +161,7 @@ export const SearchStreetsType = {
 /**
  * Error type category
  */
-export type SearchStreetsType = ClosedEnum<typeof SearchStreetsType>;
+export type SearchStreetsType = OpenEnum<typeof SearchStreetsType>;
 
 export type SearchStreetsError = {
   /**
@@ -142,20 +189,39 @@ export type SearchStreetsError = {
 /**
  * Error response
  */
-export type SearchStreetsResponseBody = {
+export type SearchStreetsResponseBodyData = {
   error: SearchStreetsError;
 };
 
-export type SearchStreetsResponse =
-  | shared.StreetQueryResponse
-  | SearchStreetsResponseBody
-  | SearchStreetsStreetsResponseBody
-  | SearchStreetsStreetsResponseResponseBody;
+/**
+ * Error response
+ */
+export class SearchStreetsResponseBody extends SDKBaseError {
+  error: SearchStreetsError;
+
+  /** The original data that was passed to this error instance. */
+  data$: SearchStreetsResponseBodyData;
+
+  constructor(
+    err: SearchStreetsResponseBodyData,
+    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 = "SearchStreetsResponseBody";
+  }
+}
 
 /** @internal */
-export const SearchStreetsStreetsResponseType$inboundSchema: z.ZodNativeEnum<
-  typeof SearchStreetsStreetsResponseType
-> = z.nativeEnum(SearchStreetsStreetsResponseType);
+export const SearchStreetsStreetsResponseType$inboundSchema: z.ZodType<
+  SearchStreetsStreetsResponseType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SearchStreetsStreetsResponseType);
 
 /** @internal */
 export const SearchStreetsStreetsResponseError$inboundSchema: z.ZodType<
@@ -191,28 +257,24 @@ export const SearchStreetsStreetsResponseResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   error: z.lazy(() => SearchStreetsStreetsResponseError$inboundSchema),
-});
-
-export function searchStreetsStreetsResponseResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  SearchStreetsStreetsResponseResponseBody,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      SearchStreetsStreetsResponseResponseBody$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'SearchStreetsStreetsResponseResponseBody' from JSON`,
-  );
-}
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new SearchStreetsStreetsResponseResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
 
 /** @internal */
-export const SearchStreetsStreetsType$inboundSchema: z.ZodNativeEnum<
-  typeof SearchStreetsStreetsType
-> = z.nativeEnum(SearchStreetsStreetsType);
+export const SearchStreetsStreetsType$inboundSchema: z.ZodType<
+  SearchStreetsStreetsType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SearchStreetsStreetsType);
 
 /** @internal */
 export const SearchStreetsStreetsError$inboundSchema: z.ZodType<
@@ -248,22 +310,24 @@ export const SearchStreetsStreetsResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   error: z.lazy(() => SearchStreetsStreetsError$inboundSchema),
-});
-
-export function searchStreetsStreetsResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchStreetsStreetsResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchStreetsStreetsResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchStreetsStreetsResponseBody' from JSON`,
-  );
-}
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new SearchStreetsStreetsResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
 
 /** @internal */
-export const SearchStreetsType$inboundSchema: z.ZodNativeEnum<
-  typeof SearchStreetsType
-> = z.nativeEnum(SearchStreetsType);
+export const SearchStreetsType$inboundSchema: z.ZodType<
+  SearchStreetsType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SearchStreetsType);
 
 /** @internal */
 export const SearchStreetsError$inboundSchema: z.ZodType<
@@ -299,36 +363,14 @@ export const SearchStreetsResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   error: z.lazy(() => SearchStreetsError$inboundSchema),
-});
-
-export function searchStreetsResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchStreetsResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchStreetsResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchStreetsResponseBody' from JSON`,
-  );
-}
-
-/** @internal */
-export const SearchStreetsResponse$inboundSchema: z.ZodType<
-  SearchStreetsResponse,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  shared.StreetQueryResponse$inboundSchema,
-  z.lazy(() => SearchStreetsResponseBody$inboundSchema),
-  z.lazy(() => SearchStreetsStreetsResponseBody$inboundSchema),
-  z.lazy(() => SearchStreetsStreetsResponseResponseBody$inboundSchema),
-]);
-
-export function searchStreetsResponseFromJSON(
-  jsonString: string,
-): SafeParseResult<SearchStreetsResponse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => SearchStreetsResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchStreetsResponse' from JSON`,
-  );
-}
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new SearchStreetsResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });

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

@@ -0,0 +1,252 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+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";
+
+/**
+ * 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 = OpenEnum<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 SearchSuggestSearchResponseBodyData = {
+  error: SearchSuggestSearchError;
+};
+
+/**
+ * Error response
+ */
+export class SearchSuggestSearchResponseBody extends SDKBaseError {
+  error: SearchSuggestSearchError;
+
+  /** The original data that was passed to this error instance. */
+  data$: SearchSuggestSearchResponseBodyData;
+
+  constructor(
+    err: SearchSuggestSearchResponseBodyData,
+    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 = "SearchSuggestSearchResponseBody";
+  }
+}
+
+/**
+ * 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 = OpenEnum<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 SearchSuggestResponseBodyData = {
+  error: SearchSuggestError;
+};
+
+/**
+ * Error response
+ */
+export class SearchSuggestResponseBody extends SDKBaseError {
+  error: SearchSuggestError;
+
+  /** The original data that was passed to this error instance. */
+  data$: SearchSuggestResponseBodyData;
+
+  constructor(
+    err: SearchSuggestResponseBodyData,
+    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 = "SearchSuggestResponseBody";
+  }
+}
+
+/** @internal */
+export const SearchSuggestSearchType$inboundSchema: z.ZodType<
+  SearchSuggestSearchType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(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),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new SearchSuggestSearchResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export const SearchSuggestType$inboundSchema: z.ZodType<
+  SearchSuggestType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(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),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new SearchSuggestResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });