@vepler/sdk 2.33.0 → 2.38.2

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

@@ -3,32 +3,69 @@
  */
 
 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";
 
 /**
- * Internal server error
+ * Error type category
  */
-export type ResolveAddressAddressResponseResponseBodyData = {
+export const ResolveAddressAddressResponseType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Error type category
+ */
+export type ResolveAddressAddressResponseType = OpenEnum<
+  typeof ResolveAddressAddressResponseType
+>;
+
+export type ResolveAddressAddressResponseError = {
+  /**
+   * 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 message
+   * Suggested corrections (e.g. postcode typo suggestions)
    */
-  error: string;
+  suggestions?: Array<string> | undefined;
   /**
-   * HTTP status code
+   * Error type category
    */
-  statusCode: number;
-  success: boolean;
+  type: ResolveAddressAddressResponseType;
 };
 
 /**
- * Internal server error
+ * Error response
+ */
+export type ResolveAddressAddressResponseResponseBodyData = {
+  error: ResolveAddressAddressResponseError;
+};
+
+/**
+ * Error response
  */
 export class ResolveAddressAddressResponseResponseBody extends SDKBaseError {
-  /**
-   * Error message
-   */
-  error: string;
-  success: boolean;
+  error: ResolveAddressAddressResponseError;
 
   /** The original data that was passed to this error instance. */
   data$: ResolveAddressAddressResponseResponseBodyData;
@@ -37,42 +74,71 @@ export class ResolveAddressAddressResponseResponseBody extends SDKBaseError {
     err: ResolveAddressAddressResponseResponseBodyData,
     httpMeta: { response: Response; request: Request; body: string },
   ) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
     super(message, httpMeta);
     this.data$ = err;
     this.error = err.error;
-    this.success = err.success;
 
     this.name = "ResolveAddressAddressResponseResponseBody";
   }
 }
 
 /**
- * Unauthorized - Invalid or missing API key
+ * Error type category
  */
-export type ResolveAddressAddressResponseBodyData = {
+export const ResolveAddressAddressType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Error type category
+ */
+export type ResolveAddressAddressType = OpenEnum<
+  typeof ResolveAddressAddressType
+>;
+
+export type ResolveAddressAddressError = {
   /**
-   * Error message
+   * Machine-readable error code
    */
-  error: string;
+  code?: string | undefined;
   /**
-   * HTTP status code
+   * URL to relevant documentation
    */
-  statusCode: number;
-  success: boolean;
+  docUrl?: string | undefined;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  /**
+   * Parameter that caused the error
+   */
+  param?: string | undefined;
+  /**
+   * Suggested corrections (e.g. postcode typo suggestions)
+   */
+  suggestions?: Array<string> | undefined;
+  /**
+   * Error type category
+   */
+  type: ResolveAddressAddressType;
+};
+
+/**
+ * Error response
+ */
+export type ResolveAddressAddressResponseBodyData = {
+  error: ResolveAddressAddressError;
 };
 
 /**
- * Unauthorized - Invalid or missing API key
+ * Error response
  */
 export class ResolveAddressAddressResponseBody extends SDKBaseError {
-  /**
-   * Error message
-   */
-  error: string;
-  success: boolean;
+  error: ResolveAddressAddressError;
 
   /** The original data that was passed to this error instance. */
   data$: ResolveAddressAddressResponseBodyData;
@@ -81,42 +147,69 @@ export class ResolveAddressAddressResponseBody extends SDKBaseError {
     err: ResolveAddressAddressResponseBodyData,
     httpMeta: { response: Response; request: Request; body: string },
   ) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
     super(message, httpMeta);
     this.data$ = err;
     this.error = err.error;
-    this.success = err.success;
 
     this.name = "ResolveAddressAddressResponseBody";
   }
 }
 
 /**
- * Invalid request parameters
+ * Error type category
  */
-export type ResolveAddressResponseBodyData = {
+export const ResolveAddressType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Error type category
+ */
+export type ResolveAddressType = OpenEnum<typeof ResolveAddressType>;
+
+export type ResolveAddressError = {
   /**
-   * Error message
+   * Machine-readable error code
    */
-  error: string;
+  code?: string | undefined;
   /**
-   * HTTP status code
+   * URL to relevant documentation
    */
-  statusCode: number;
-  success: boolean;
+  docUrl?: string | undefined;
+  /**
+   * Human-readable error message
+   */
+  message: string;
+  /**
+   * Parameter that caused the error
+   */
+  param?: string | undefined;
+  /**
+   * Suggested corrections (e.g. postcode typo suggestions)
+   */
+  suggestions?: Array<string> | undefined;
+  /**
+   * Error type category
+   */
+  type: ResolveAddressType;
+};
+
+/**
+ * Error response
+ */
+export type ResolveAddressResponseBodyData = {
+  error: ResolveAddressError;
 };
 
 /**
- * Invalid request parameters
+ * Error response
  */
 export class ResolveAddressResponseBody extends SDKBaseError {
-  /**
-   * Error message
-   */
-  error: string;
-  success: boolean;
+  error: ResolveAddressError;
 
   /** The original data that was passed to this error instance. */
   data$: ResolveAddressResponseBodyData;
@@ -125,27 +218,59 @@ export class ResolveAddressResponseBody extends SDKBaseError {
     err: ResolveAddressResponseBodyData,
     httpMeta: { response: Response; request: Request; body: string },
   ) {
-    const message = "message" in err && typeof err.message === "string"
-      ? err.message
-      : `API error occurred: ${JSON.stringify(err)}`;
+    const message = err.error?.message
+      || `API error occurred: ${JSON.stringify(err)}`;
     super(message, httpMeta);
     this.data$ = err;
     this.error = err.error;
-    this.success = err.success;
 
     this.name = "ResolveAddressResponseBody";
   }
 }
 
+/** @internal */
+export const ResolveAddressAddressResponseType$inboundSchema: z.ZodType<
+  ResolveAddressAddressResponseType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ResolveAddressAddressResponseType);
+
+/** @internal */
+export const ResolveAddressAddressResponseError$inboundSchema: z.ZodType<
+  ResolveAddressAddressResponseError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  suggestions: z.array(z.string()).optional(),
+  type: ResolveAddressAddressResponseType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function resolveAddressAddressResponseErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<ResolveAddressAddressResponseError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ResolveAddressAddressResponseError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResolveAddressAddressResponseError' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResolveAddressAddressResponseResponseBody$inboundSchema: z.ZodType<
   ResolveAddressAddressResponseResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  error: z.string(),
-  statusCode: z.number(),
-  success: z.boolean(),
+  error: z.lazy(() => ResolveAddressAddressResponseError$inboundSchema),
   request$: z.instanceof(Request),
   response$: z.instanceof(Response),
   body$: z.string(),
@@ -158,15 +283,48 @@ export const ResolveAddressAddressResponseResponseBody$inboundSchema: z.ZodType<
     });
   });
 
+/** @internal */
+export const ResolveAddressAddressType$inboundSchema: z.ZodType<
+  ResolveAddressAddressType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ResolveAddressAddressType);
+
+/** @internal */
+export const ResolveAddressAddressError$inboundSchema: z.ZodType<
+  ResolveAddressAddressError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  suggestions: z.array(z.string()).optional(),
+  type: ResolveAddressAddressType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function resolveAddressAddressErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<ResolveAddressAddressError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResolveAddressAddressError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResolveAddressAddressError' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResolveAddressAddressResponseBody$inboundSchema: z.ZodType<
   ResolveAddressAddressResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  error: z.string(),
-  statusCode: z.number(),
-  success: z.boolean(),
+  error: z.lazy(() => ResolveAddressAddressError$inboundSchema),
   request$: z.instanceof(Request),
   response$: z.instanceof(Response),
   body$: z.string(),
@@ -179,15 +337,48 @@ export const ResolveAddressAddressResponseBody$inboundSchema: z.ZodType<
     });
   });
 
+/** @internal */
+export const ResolveAddressType$inboundSchema: z.ZodType<
+  ResolveAddressType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ResolveAddressType);
+
+/** @internal */
+export const ResolveAddressError$inboundSchema: z.ZodType<
+  ResolveAddressError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string().optional(),
+  doc_url: z.string().optional(),
+  message: z.string(),
+  param: z.string().optional(),
+  suggestions: z.array(z.string()).optional(),
+  type: ResolveAddressType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function resolveAddressErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<ResolveAddressError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResolveAddressError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResolveAddressError' from JSON`,
+  );
+}
+
 /** @internal */
 export const ResolveAddressResponseBody$inboundSchema: z.ZodType<
   ResolveAddressResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  error: z.string(),
-  statusCode: z.number(),
-  success: z.boolean(),
+  error: z.lazy(() => ResolveAddressError$inboundSchema),
   request$: z.instanceof(Request),
   response$: z.instanceof(Response),
   body$: z.string(),