@vepler/sdk 7.1.2 → 7.7.0

package/src/funcs/noisePoint.ts

@@ -0,0 +1,184 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SDKCore } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../sdk/models/errors/httpclienterrors.js";
+import * as errors from "../sdk/models/errors/index.js";
+import { ResponseValidationError } from "../sdk/models/errors/responsevalidationerror.js";
+import { SDKBaseError } from "../sdk/models/errors/sdkbaseerror.js";
+import { SDKValidationError } from "../sdk/models/errors/sdkvalidationerror.js";
+import * as shared from "../sdk/models/shared/index.js";
+import { APICall, APIPromise } from "../sdk/types/async.js";
+import { Result } from "../sdk/types/fp.js";
+
+/**
+ * Read road and rail noise at a coordinate
+ *
+ * @remarks
+ * Returns road traffic and railway noise at one latitude and longitude, each as a day-evening-night level (Lden) and a night level (Lnight) in decibels. Read `status` on each reading before its level: `mapped` carries a level, `below_floor` states the lowest level the map draws instead of a level, and `not_covered` means no map covers the point or the metric is not available there. Each reading names its map's publisher, round, data year, edition and licence where the map states them, with the attribution and any use limitation the publisher requires to be shown alongside it. `nations` lists which UK nations the maps cover.
+ */
+export function noisePoint(
+  client: SDKCore,
+  request?: shared.NoisePointRequest | undefined,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    shared.NoisePointResponse,
+    | errors.QueryNoisePointResponseBody
+    | errors.QueryNoisePointNoiseResponseBody
+    | errors.QueryNoisePointNoiseResponseResponseBody
+    | SDKBaseError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: SDKCore,
+  request?: shared.NoisePointRequest | undefined,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      shared.NoisePointResponse,
+      | errors.QueryNoisePointResponseBody
+      | errors.QueryNoisePointNoiseResponseBody
+      | errors.QueryNoisePointNoiseResponseResponseBody
+      | SDKBaseError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => shared.NoisePointRequest$outboundSchema.optional().parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = payload === undefined
+    ? null
+    : encodeJSON("body", payload, { explode: true });
+
+  const path = pathToFunc("/v1/noise/point")();
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "queryNoisePoint",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    shared.NoisePointResponse,
+    | errors.QueryNoisePointResponseBody
+    | errors.QueryNoisePointNoiseResponseBody
+    | errors.QueryNoisePointNoiseResponseResponseBody
+    | SDKBaseError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, shared.NoisePointResponse$inboundSchema),
+    M.jsonErr(400, errors.QueryNoisePointResponseBody$inboundSchema),
+    M.jsonErr(500, errors.QueryNoisePointNoiseResponseBody$inboundSchema),
+    M.jsonErr(
+      503,
+      errors.QueryNoisePointNoiseResponseResponseBody$inboundSchema,
+    ),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/poiGetNearestPOI.ts

@@ -30,7 +30,7 @@ import { Result } from "../sdk/types/fp.js";
  * Find nearest points of interest
  *
  * @remarks
- * Returns the points of interest closest to a location, nearest first, with the straight-line distance to each. Narrow the search with `types`, and add distances and times along roads and paths with `routing`.
+ * Returns the points of interest closest to a location, nearest first, with the straight-line distance and the direction to each. Narrow the search with `types`, and add distances and times by car, by bicycle and on foot with `routing`.
  */
 export function poiGetNearestPOI(
   client: SDKCore,

package/src/lib/config.ts

@@ -60,8 +60,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 
 export const SDK_METADATA = {
   language: "typescript",
-  openapiDocVersion: "7.1.2",
+  openapiDocVersion: "7.7.0",
   sdkVersion: "0.12.0",
   genVersion: "2.954.8",
-  userAgent: "speakeasy-sdk/typescript 0.12.0 2.954.8 7.1.2 @vepler/sdk",
+  userAgent: "speakeasy-sdk/typescript 0.12.0 2.954.8 7.7.0 @vepler/sdk",
 } as const;

package/src/sdk/areas.ts

@@ -7,8 +7,11 @@ import { areasGetAreasWithin } from "../funcs/areasGetAreasWithin.js";
 import { areasGetBorderingAreas } from "../funcs/areasGetBorderingAreas.js";
 import { areasGetChildAreas } from "../funcs/areasGetChildAreas.js";
 import { areasGetCoverage } from "../funcs/areasGetCoverage.js";
+import { areasGetNearestHistoricLandfill } from "../funcs/areasGetNearestHistoricLandfill.js";
+import { areasGetRadonAtPoint } from "../funcs/areasGetRadonAtPoint.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 Areas extends ClientSDK {
@@ -96,4 +99,38 @@ export class Areas extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Find the nearest historic landfill site
+   *
+   * @remarks
+   * Returns the historic landfill site whose outline is nearest a latitude and longitude, if one lies within `radius` metres of it: its name, the distance to the outline's nearest edge, the direction of that edge from the point, and the outline. When none does, `found` is false and `radiusM` says how far was searched. Read `covered` before treating `found: false` as a clear result: it is true only in England and Wales, where the regulators' historic landfill records are held. `edition` names the release of the record the answer was read from.
+   */
+  async getNearestHistoricLandfill(
+    request?: operations.GetNearestHistoricLandfillRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<shared.HistoricLandfillNearestResponse> {
+    return unwrapAsync(areasGetNearestHistoricLandfill(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get the radon class at a point
+   *
+   * @remarks
+   * Returns the 1 km square of the Indicative Atlas of Radon that contains a latitude and longitude, with its radon class from 1 to 6, the band of homes estimated to be at or above the radon Action Level that the class stands for, the square's outline, and the atlas release it was read from, with its date, publisher and licence. When no square contains the point, `covered` is false and `square` is null, so a point the atlas does not map is never answered with a low class.
+   */
+  async getRadonAtPoint(
+    request?: operations.GetRadonAtPointRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<shared.RadonPointResponse> {
+    return unwrapAsync(areasGetRadonAtPoint(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/floodrisk.ts

@@ -12,7 +12,7 @@ export class FloodRisk extends ClientSDK {
    * Assess flood risk at a coordinate
    *
    * @remarks
-   * Returns the flood risk at one latitude and longitude, from the Environment Agency National Flood Risk Assessment 2. Rivers and sea (with the depth if it floods) and surface water (with hazard and flow velocity) are reported separately, alongside the present-day risk and, where it differs, the 2080 climate projection. The planning flood zone and nearby defences are included when the point has them. Read `dataAvailability` on every response before reading the bands: it says whether the point was assessed, sits outside every modelled flood extent, or is not yet covered, and `overallRiskLevel` is null rather than reassuring wherever no assessment was possible.
+   * Returns the flood risk at one latitude and longitude, from the Environment Agency National Flood Risk Assessment 2. Rivers and sea (with the depth if it floods) and surface water (with hazard and flow velocity) are reported separately, alongside the present-day risk and the Environment Agency's climate change projection, with the period and allowances it was modelled for. The planning flood zone and nearby defences are included when the point has them. Read `dataAvailability` on every response before reading the bands: it says whether the point was assessed, sits outside every modelled flood extent, or is not yet covered, and `overallRiskLevel` is null rather than reassuring wherever no assessment was possible.
    */
   async point(
     request?: shared.FloodRiskPointRequest | undefined,

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

@@ -0,0 +1,408 @@
+/*
+ * 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";
+
+/**
+ * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+ */
+export const GetNearestHistoricLandfillAreasResponseType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+ */
+export type GetNearestHistoricLandfillAreasResponseType = OpenEnum<
+  typeof GetNearestHistoricLandfillAreasResponseType
+>;
+
+export type GetNearestHistoricLandfillAreasResponseError = {
+  /**
+   * Stable code identifying the specific failure, safe to branch on.
+   */
+  code?: string | undefined;
+  /**
+   * Link to the documentation for this error.
+   */
+  docUrl?: string | undefined;
+  /**
+   * Human-readable explanation of what went wrong.
+   */
+  message: string;
+  /**
+   * Name of the request parameter at fault, where the failure can be traced to one.
+   */
+  param?: string | undefined;
+  /**
+   * Alternative values worth retrying when the supplied one could not be matched.
+   */
+  suggestions?: Array<string> | undefined;
+  /**
+   * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+   */
+  type: GetNearestHistoricLandfillAreasResponseType;
+};
+
+/**
+ * Returned in place of the normal payload whenever a request fails.
+ */
+export type GetNearestHistoricLandfillAreasResponseResponseBodyData = {
+  error: GetNearestHistoricLandfillAreasResponseError;
+};
+
+/**
+ * Returned in place of the normal payload whenever a request fails.
+ */
+export class GetNearestHistoricLandfillAreasResponseResponseBody
+  extends SDKBaseError
+{
+  error: GetNearestHistoricLandfillAreasResponseError;
+
+  /** The original data that was passed to this error instance. */
+  data$: GetNearestHistoricLandfillAreasResponseResponseBodyData;
+
+  constructor(
+    err: GetNearestHistoricLandfillAreasResponseResponseBodyData,
+    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 = "GetNearestHistoricLandfillAreasResponseResponseBody";
+  }
+}
+
+/**
+ * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+ */
+export const GetNearestHistoricLandfillAreasType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+ */
+export type GetNearestHistoricLandfillAreasType = OpenEnum<
+  typeof GetNearestHistoricLandfillAreasType
+>;
+
+export type GetNearestHistoricLandfillAreasError = {
+  /**
+   * Stable code identifying the specific failure, safe to branch on.
+   */
+  code?: string | undefined;
+  /**
+   * Link to the documentation for this error.
+   */
+  docUrl?: string | undefined;
+  /**
+   * Human-readable explanation of what went wrong.
+   */
+  message: string;
+  /**
+   * Name of the request parameter at fault, where the failure can be traced to one.
+   */
+  param?: string | undefined;
+  /**
+   * Alternative values worth retrying when the supplied one could not be matched.
+   */
+  suggestions?: Array<string> | undefined;
+  /**
+   * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+   */
+  type: GetNearestHistoricLandfillAreasType;
+};
+
+/**
+ * Returned in place of the normal payload whenever a request fails.
+ */
+export type GetNearestHistoricLandfillAreasResponseBodyData = {
+  error: GetNearestHistoricLandfillAreasError;
+};
+
+/**
+ * Returned in place of the normal payload whenever a request fails.
+ */
+export class GetNearestHistoricLandfillAreasResponseBody extends SDKBaseError {
+  error: GetNearestHistoricLandfillAreasError;
+
+  /** The original data that was passed to this error instance. */
+  data$: GetNearestHistoricLandfillAreasResponseBodyData;
+
+  constructor(
+    err: GetNearestHistoricLandfillAreasResponseBodyData,
+    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 = "GetNearestHistoricLandfillAreasResponseBody";
+  }
+}
+
+/**
+ * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+ */
+export const GetNearestHistoricLandfillType = {
+  ApiError: "api_error",
+  InvalidRequestError: "invalid_request_error",
+  AuthenticationError: "authentication_error",
+  RateLimitError: "rate_limit_error",
+} as const;
+/**
+ * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+ */
+export type GetNearestHistoricLandfillType = OpenEnum<
+  typeof GetNearestHistoricLandfillType
+>;
+
+export type GetNearestHistoricLandfillError = {
+  /**
+   * Stable code identifying the specific failure, safe to branch on.
+   */
+  code?: string | undefined;
+  /**
+   * Link to the documentation for this error.
+   */
+  docUrl?: string | undefined;
+  /**
+   * Human-readable explanation of what went wrong.
+   */
+  message: string;
+  /**
+   * Name of the request parameter at fault, where the failure can be traced to one.
+   */
+  param?: string | undefined;
+  /**
+   * Alternative values worth retrying when the supplied one could not be matched.
+   */
+  suggestions?: Array<string> | undefined;
+  /**
+   * Broad category of the failure: a malformed request, an authentication problem, a rate limit, or a fault on the server side.
+   */
+  type: GetNearestHistoricLandfillType;
+};
+
+/**
+ * Returned in place of the normal payload whenever a request fails.
+ */
+export type GetNearestHistoricLandfillResponseBodyData = {
+  error: GetNearestHistoricLandfillError;
+};
+
+/**
+ * Returned in place of the normal payload whenever a request fails.
+ */
+export class GetNearestHistoricLandfillResponseBody extends SDKBaseError {
+  error: GetNearestHistoricLandfillError;
+
+  /** The original data that was passed to this error instance. */
+  data$: GetNearestHistoricLandfillResponseBodyData;
+
+  constructor(
+    err: GetNearestHistoricLandfillResponseBodyData,
+    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 = "GetNearestHistoricLandfillResponseBody";
+  }
+}
+
+/** @internal */
+export const GetNearestHistoricLandfillAreasResponseType$inboundSchema:
+  z.ZodType<
+    GetNearestHistoricLandfillAreasResponseType,
+    z.ZodTypeDef,
+    unknown
+  > = openEnums.inboundSchema(GetNearestHistoricLandfillAreasResponseType);
+
+/** @internal */
+export const GetNearestHistoricLandfillAreasResponseError$inboundSchema:
+  z.ZodType<
+    GetNearestHistoricLandfillAreasResponseError,
+    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: GetNearestHistoricLandfillAreasResponseType$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "doc_url": "docUrl",
+    });
+  });
+
+export function getNearestHistoricLandfillAreasResponseErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetNearestHistoricLandfillAreasResponseError,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetNearestHistoricLandfillAreasResponseError$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetNearestHistoricLandfillAreasResponseError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetNearestHistoricLandfillAreasResponseResponseBody$inboundSchema:
+  z.ZodType<
+    GetNearestHistoricLandfillAreasResponseResponseBody,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    error: z.lazy(() =>
+      GetNearestHistoricLandfillAreasResponseError$inboundSchema
+    ),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
+  })
+    .transform((v) => {
+      return new GetNearestHistoricLandfillAreasResponseResponseBody(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    });
+
+/** @internal */
+export const GetNearestHistoricLandfillAreasType$inboundSchema: z.ZodType<
+  GetNearestHistoricLandfillAreasType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(GetNearestHistoricLandfillAreasType);
+
+/** @internal */
+export const GetNearestHistoricLandfillAreasError$inboundSchema: z.ZodType<
+  GetNearestHistoricLandfillAreasError,
+  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: GetNearestHistoricLandfillAreasType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function getNearestHistoricLandfillAreasErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetNearestHistoricLandfillAreasError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetNearestHistoricLandfillAreasError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetNearestHistoricLandfillAreasError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetNearestHistoricLandfillAreasResponseBody$inboundSchema:
+  z.ZodType<
+    GetNearestHistoricLandfillAreasResponseBody,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    error: z.lazy(() => GetNearestHistoricLandfillAreasError$inboundSchema),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
+  })
+    .transform((v) => {
+      return new GetNearestHistoricLandfillAreasResponseBody(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
+    });
+
+/** @internal */
+export const GetNearestHistoricLandfillType$inboundSchema: z.ZodType<
+  GetNearestHistoricLandfillType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(GetNearestHistoricLandfillType);
+
+/** @internal */
+export const GetNearestHistoricLandfillError$inboundSchema: z.ZodType<
+  GetNearestHistoricLandfillError,
+  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: GetNearestHistoricLandfillType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "doc_url": "docUrl",
+  });
+});
+
+export function getNearestHistoricLandfillErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<GetNearestHistoricLandfillError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetNearestHistoricLandfillError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetNearestHistoricLandfillError' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetNearestHistoricLandfillResponseBody$inboundSchema: z.ZodType<
+  GetNearestHistoricLandfillResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.lazy(() => GetNearestHistoricLandfillError$inboundSchema),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new GetNearestHistoricLandfillResponseBody(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });