@vepler/sdk 7.1.2 → 7.7.0

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

@@ -0,0 +1,56 @@
+/*
+ * 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";
+import { HazardEdition, HazardEdition$inboundSchema } from "./hazardedition.js";
+import {
+  HistoricLandfillSite,
+  HistoricLandfillSite$inboundSchema,
+} from "./historiclandfillsite.js";
+
+export type HistoricLandfillNearestResponse = {
+  /**
+   * Whether the point is in England or Wales and the historic landfill record for that nation is held. Elsewhere a site near the border can still be found, but `found: false` there does not show that none exists.
+   */
+  covered: boolean;
+  edition: HazardEdition | null;
+  /**
+   * Whether a historic landfill site lies within `radiusM` of the point.
+   */
+  found: boolean;
+  /**
+   * The radius searched, in metres.
+   */
+  radiusM: number;
+  /**
+   * The site whose outline is nearest the point. Null when `found` is false.
+   */
+  site: HistoricLandfillSite | null;
+};
+
+/** @internal */
+export const HistoricLandfillNearestResponse$inboundSchema: z.ZodType<
+  HistoricLandfillNearestResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  covered: z.boolean(),
+  edition: z.nullable(HazardEdition$inboundSchema),
+  found: z.boolean(),
+  radiusM: z.number().int(),
+  site: z.nullable(HistoricLandfillSite$inboundSchema),
+});
+
+export function historicLandfillNearestResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<HistoricLandfillNearestResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HistoricLandfillNearestResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HistoricLandfillNearestResponse' from JSON`,
+  );
+}

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

@@ -0,0 +1,58 @@
+/*
+ * 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";
+import { HazardOutline, HazardOutline$inboundSchema } from "./hazardoutline.js";
+
+/**
+ * The site whose outline is nearest the point. Null when `found` is false.
+ */
+export type HistoricLandfillSite = {
+  /**
+   * Direction from the point to the nearest point of the outline, in degrees clockwise from true north, to one decimal place. Null when `distanceM` is 0.
+   */
+  bearingDeg: number | null;
+  /**
+   * Distance in metres from the point to the nearest edge of the site's outline, to one decimal place. 0 when the point is on or inside the outline.
+   */
+  distanceM: number;
+  /**
+   * The site's name as the record gives it.
+   */
+  name: string;
+  /**
+   * The outline as a GeoJSON MultiPolygon in WGS84.
+   */
+  outline: HazardOutline;
+  /**
+   * The site's reference in the historic landfill record.
+   */
+  reference: string;
+};
+
+/** @internal */
+export const HistoricLandfillSite$inboundSchema: z.ZodType<
+  HistoricLandfillSite,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bearingDeg: z.nullable(z.number()),
+  distanceM: z.number(),
+  name: z.string(),
+  outline: HazardOutline$inboundSchema,
+  reference: z.string(),
+});
+
+export function historicLandfillSiteFromJSON(
+  jsonString: string,
+): SafeParseResult<HistoricLandfillSite, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HistoricLandfillSite$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HistoricLandfillSite' from JSON`,
+  );
+}

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

@@ -176,6 +176,11 @@ export * from "./exceedancelevel.js";
 export * from "./extendedstatsaggregationresult.js";
 export * from "./extractioncitation.js";
 export * from "./floodclimate2080.js";
+export * from "./floodclimateallowance.js";
+export * from "./floodclimateallowancelevel.js";
+export * from "./floodclimatedriver.js";
+export * from "./floodclimateprojection.js";
+export * from "./floodclimateprojectionsource.js";
 export * from "./flooddataavailability.js";
 export * from "./flooddefence.js";
 export * from "./floodhazardrating.js";
@@ -203,6 +208,8 @@ export * from "./geographymetricslistresponse.js";
 export * from "./geographymetricsrow.js";
 export * from "./geographyrelatedarea.js";
 export * from "./geographytimeseriespoint.js";
+export * from "./hazardedition.js";
+export * from "./hazardoutline.js";
 export * from "./healthevidencelevel.js";
 export * from "./healthimpact.js";
 export * from "./healthimpactseverity.js";
@@ -214,6 +221,8 @@ export * from "./heritagezone.js";
 export * from "./histogramaggregationresult.js";
 export * from "./histogrambucket.js";
 export * from "./historicalvaluation.js";
+export * from "./historiclandfillnearestresponse.js";
+export * from "./historiclandfillsite.js";
 export * from "./imagecondition.js";
 export * from "./imagedocumentclass.js";
 export * from "./imagequality.js";
@@ -256,6 +265,16 @@ export * from "./mortgagecharge.js";
 export * from "./nearestpostcodesresponse.js";
 export * from "./nestedaggregation.js";
 export * from "./nestedaggregationresult.js";
+export * from "./noiseband.js";
+export * from "./noisebandset.js";
+export * from "./noisemapsource.js";
+export * from "./noisenationcoverage.js";
+export * from "./noisepointcoordinate.js";
+export * from "./noisepointrequest.js";
+export * from "./noisepointresponse.js";
+export * from "./noisereading.js";
+export * from "./noisereadingstatus.js";
+export * from "./noisesourcereadings.js";
 export * from "./observedfeature.js";
 export * from "./officer.js";
 export * from "./officerlistresponse.js";
@@ -352,6 +371,9 @@ export * from "./pscresponse.js";
 export * from "./pscstatement.js";
 export * from "./pscsummary.js";
 export * from "./purchasestatus.js";
+export * from "./radonpointresponse.js";
+export * from "./radonpotentialband.js";
+export * from "./radonsquare.js";
 export * from "./rangedefinition.js";
 export * from "./refurbishmentdata.js";
 export * from "./registeredcharges.js";

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

@@ -0,0 +1,47 @@
+/*
+ * 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";
+
+/**
+ * The band from `bandSet` the level falls in. Null when there is no level, the level is below the quietest band, or the metric has no band set.
+ */
+export type NoiseBand = {
+  /**
+   * Band code, such as `ROAD_NOISE_MED`.
+   */
+  code: string;
+  /**
+   * Lowest level in the band, in decibels, inclusive.
+   */
+  fromDb: number;
+  /**
+   * Level the band stops below, in decibels. Null for the loudest band, which has no upper limit.
+   */
+  toDb: number | null;
+};
+
+/** @internal */
+export const NoiseBand$inboundSchema: z.ZodType<
+  NoiseBand,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  fromDb: z.number(),
+  toDb: z.nullable(z.number()),
+});
+
+export function noiseBandFromJSON(
+  jsonString: string,
+): SafeParseResult<NoiseBand, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NoiseBand$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NoiseBand' from JSON`,
+  );
+}

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

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 { NoiseBand, NoiseBand$inboundSchema } from "./noiseband.js";
+
+/**
+ * Who set the bands. `vepler` means Vepler's own bands, the same ones the site and property noise overlay tags use. They are not the noise maps' published bands.
+ */
+export const NoiseBandSetSource = {
+  Vepler: "vepler",
+} as const;
+/**
+ * Who set the bands. `vepler` means Vepler's own bands, the same ones the site and property noise overlay tags use. They are not the noise maps' published bands.
+ */
+export type NoiseBandSetSource = ClosedEnum<typeof NoiseBandSetSource>;
+
+/**
+ * The bands this metric is banded with. Null for Lnight.
+ */
+export type NoiseBandSet = {
+  /**
+   * The bands, quietest first.
+   */
+  bands: Array<NoiseBand | null>;
+  /**
+   * Who set the bands. `vepler` means Vepler's own bands, the same ones the site and property noise overlay tags use. They are not the noise maps' published bands.
+   */
+  source: NoiseBandSetSource;
+};
+
+/** @internal */
+export const NoiseBandSetSource$inboundSchema: z.ZodNativeEnum<
+  typeof NoiseBandSetSource
+> = z.nativeEnum(NoiseBandSetSource);
+
+/** @internal */
+export const NoiseBandSet$inboundSchema: z.ZodType<
+  NoiseBandSet,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bands: z.array(z.nullable(NoiseBand$inboundSchema)),
+  source: NoiseBandSetSource$inboundSchema,
+});
+
+export function noiseBandSetFromJSON(
+  jsonString: string,
+): SafeParseResult<NoiseBandSet, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NoiseBandSet$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NoiseBandSet' from JSON`,
+  );
+}

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

@@ -0,0 +1,140 @@
+/*
+ * 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * `stated` when the publisher states the data year, `inferred` when it is worked out from the regulations the map was made under. Null when the basis is not recorded.
+ */
+export const DataYearBasis = {
+  Stated: "stated",
+  Inferred: "inferred",
+} as const;
+/**
+ * `stated` when the publisher states the data year, `inferred` when it is worked out from the regulations the map was made under. Null when the basis is not recorded.
+ */
+export type DataYearBasis = OpenEnum<typeof DataYearBasis>;
+
+/**
+ * The nation whose map the reading comes from. Null when the map does not state it.
+ */
+export const NoiseMapSourceNation = {
+  Eng: "ENG",
+  Sco: "SCO",
+  Wal: "WAL",
+  Nir: "NIR",
+} as const;
+/**
+ * The nation whose map the reading comes from. Null when the map does not state it.
+ */
+export type NoiseMapSourceNation = OpenEnum<typeof NoiseMapSourceNation>;
+
+/**
+ * `stated` when the publisher states the round, `inferred` when it is worked out from the regulations the map was made under. Null when `round` is null.
+ */
+export const RoundBasis = {
+  Stated: "stated",
+  Inferred: "inferred",
+} as const;
+/**
+ * `stated` when the publisher states the round, `inferred` when it is worked out from the regulations the map was made under. Null when `round` is null.
+ */
+export type RoundBasis = OpenEnum<typeof RoundBasis>;
+
+export type NoiseMapSource = {
+  /**
+   * The attribution the licence requires to be shown wherever the reading is shown.
+   */
+  attribution: string | null;
+  /**
+   * The year the map models noise for. Null when not stated.
+   */
+  dataYear: number | null;
+  /**
+   * `stated` when the publisher states the data year, `inferred` when it is worked out from the regulations the map was made under. Null when the basis is not recorded.
+   */
+  dataYearBasis: DataYearBasis | null;
+  /**
+   * The date the publisher published this edition of the map, as an ISO 8601 date. Null when not stated.
+   */
+  edition: string | null;
+  /**
+   * The licence the map is published under, such as `OGL-UK-3.0`.
+   */
+  licence: string | null;
+  /**
+   * The nation whose map the reading comes from. Null when the map does not state it.
+   */
+  nation: NoiseMapSourceNation | null;
+  /**
+   * The body that publishes the map, such as the Welsh Government. Null when not stated.
+   */
+  publisher: string | null;
+  /**
+   * The strategic noise mapping round the map belongs to, such as 4. Null when not stated.
+   */
+  round: number | null;
+  /**
+   * `stated` when the publisher states the round, `inferred` when it is worked out from the regulations the map was made under. Null when `round` is null.
+   */
+  roundBasis: RoundBasis | null;
+  /**
+   * The publisher's own limitation on how the map may be used, to be shown with the reading. Null when the publisher states none.
+   */
+  useLimitation: string | null;
+};
+
+/** @internal */
+export const DataYearBasis$inboundSchema: z.ZodType<
+  DataYearBasis,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(DataYearBasis);
+
+/** @internal */
+export const NoiseMapSourceNation$inboundSchema: z.ZodType<
+  NoiseMapSourceNation,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(NoiseMapSourceNation);
+
+/** @internal */
+export const RoundBasis$inboundSchema: z.ZodType<
+  RoundBasis,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RoundBasis);
+
+/** @internal */
+export const NoiseMapSource$inboundSchema: z.ZodType<
+  NoiseMapSource,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  attribution: z.nullable(z.string()),
+  dataYear: z.nullable(z.number().int()),
+  dataYearBasis: z.nullable(DataYearBasis$inboundSchema),
+  edition: z.nullable(z.string()),
+  licence: z.nullable(z.string()),
+  nation: z.nullable(NoiseMapSourceNation$inboundSchema),
+  publisher: z.nullable(z.string()),
+  round: z.nullable(z.number().int()),
+  roundBasis: z.nullable(RoundBasis$inboundSchema),
+  useLimitation: z.nullable(z.string()),
+});
+
+export function noiseMapSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<NoiseMapSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NoiseMapSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NoiseMapSource' from JSON`,
+  );
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * UK nation.
+ */
+export const NoiseNationCoverageNation = {
+  Eng: "ENG",
+  Sco: "SCO",
+  Wal: "WAL",
+  Nir: "NIR",
+} as const;
+/**
+ * UK nation.
+ */
+export type NoiseNationCoverageNation = OpenEnum<
+  typeof NoiseNationCoverageNation
+>;
+
+export type NoiseNationCoverage = {
+  /**
+   * Whether the road and rail noise maps cover this nation.
+   */
+  covered: boolean;
+  /**
+   * UK nation.
+   */
+  nation: NoiseNationCoverageNation;
+};
+
+/** @internal */
+export const NoiseNationCoverageNation$inboundSchema: z.ZodType<
+  NoiseNationCoverageNation,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(NoiseNationCoverageNation);
+
+/** @internal */
+export const NoiseNationCoverage$inboundSchema: z.ZodType<
+  NoiseNationCoverage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  covered: z.boolean(),
+  nation: NoiseNationCoverageNation$inboundSchema,
+});
+
+export function noiseNationCoverageFromJSON(
+  jsonString: string,
+): SafeParseResult<NoiseNationCoverage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NoiseNationCoverage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NoiseNationCoverage' from JSON`,
+  );
+}

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

@@ -0,0 +1,61 @@
+/*
+ * 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 NoisePointCoordinate = {
+  /**
+   * Latitude in WGS84 decimal degrees. Between 49 and 61.
+   */
+  lat: number;
+  /**
+   * Longitude in WGS84 decimal degrees. Between -9 and 2.
+   */
+  lon: number;
+};
+
+/** @internal */
+export const NoisePointCoordinate$inboundSchema: z.ZodType<
+  NoisePointCoordinate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lon: z.number(),
+});
+/** @internal */
+export type NoisePointCoordinate$Outbound = {
+  lat: number;
+  lon: number;
+};
+
+/** @internal */
+export const NoisePointCoordinate$outboundSchema: z.ZodType<
+  NoisePointCoordinate$Outbound,
+  z.ZodTypeDef,
+  NoisePointCoordinate
+> = z.object({
+  lat: z.number(),
+  lon: z.number(),
+});
+
+export function noisePointCoordinateToJSON(
+  noisePointCoordinate: NoisePointCoordinate,
+): string {
+  return JSON.stringify(
+    NoisePointCoordinate$outboundSchema.parse(noisePointCoordinate),
+  );
+}
+export function noisePointCoordinateFromJSON(
+  jsonString: string,
+): SafeParseResult<NoisePointCoordinate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NoisePointCoordinate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NoisePointCoordinate' from JSON`,
+  );
+}

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

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  NoisePointCoordinate,
+  NoisePointCoordinate$Outbound,
+  NoisePointCoordinate$outboundSchema,
+} from "./noisepointcoordinate.js";
+
+export type NoisePointRequest = {
+  coordinate: NoisePointCoordinate;
+};
+
+/** @internal */
+export type NoisePointRequest$Outbound = {
+  coordinate: NoisePointCoordinate$Outbound;
+};
+
+/** @internal */
+export const NoisePointRequest$outboundSchema: z.ZodType<
+  NoisePointRequest$Outbound,
+  z.ZodTypeDef,
+  NoisePointRequest
+> = z.object({
+  coordinate: NoisePointCoordinate$outboundSchema,
+});
+
+export function noisePointRequestToJSON(
+  noisePointRequest: NoisePointRequest,
+): string {
+  return JSON.stringify(
+    NoisePointRequest$outboundSchema.parse(noisePointRequest),
+  );
+}

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

@@ -0,0 +1,109 @@
+/*
+ * 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  NoiseNationCoverage,
+  NoiseNationCoverage$inboundSchema,
+} from "./noisenationcoverage.js";
+import {
+  NoisePointCoordinate,
+  NoisePointCoordinate$inboundSchema,
+} from "./noisepointcoordinate.js";
+import {
+  NoiseSourceReadings,
+  NoiseSourceReadings$inboundSchema,
+} from "./noisesourcereadings.js";
+
+/**
+ * `covered` when the noise maps cover the point. `not_covered` when they do not, in which case every reading is `not_covered` and says nothing about the noise there.
+ */
+export const Coverage = {
+  Covered: "covered",
+  NotCovered: "not_covered",
+} as const;
+/**
+ * `covered` when the noise maps cover the point. `not_covered` when they do not, in which case every reading is `not_covered` and says nothing about the noise there.
+ */
+export type Coverage = OpenEnum<typeof Coverage>;
+
+/**
+ * UK nation the point lies in. Null when the point is not in the UK.
+ */
+export const NoisePointResponseNation = {
+  Eng: "ENG",
+  Sco: "SCO",
+  Wal: "WAL",
+  Nir: "NIR",
+} as const;
+/**
+ * UK nation the point lies in. Null when the point is not in the UK.
+ */
+export type NoisePointResponseNation = OpenEnum<
+  typeof NoisePointResponseNation
+>;
+
+export type NoisePointResponse = {
+  coordinate: NoisePointCoordinate;
+  /**
+   * `covered` when the noise maps cover the point. `not_covered` when they do not, in which case every reading is `not_covered` and says nothing about the noise there.
+   */
+  coverage: Coverage;
+  /**
+   * UK nation the point lies in. Null when the point is not in the UK.
+   */
+  nation: NoisePointResponseNation | null;
+  /**
+   * Which UK nations the noise maps cover.
+   */
+  nations: Array<NoiseNationCoverage>;
+  rail: NoiseSourceReadings;
+  /**
+   * Road traffic noise at the point.
+   */
+  road: NoiseSourceReadings;
+};
+
+/** @internal */
+export const Coverage$inboundSchema: z.ZodType<
+  Coverage,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Coverage);
+
+/** @internal */
+export const NoisePointResponseNation$inboundSchema: z.ZodType<
+  NoisePointResponseNation,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(NoisePointResponseNation);
+
+/** @internal */
+export const NoisePointResponse$inboundSchema: z.ZodType<
+  NoisePointResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinate: NoisePointCoordinate$inboundSchema,
+  coverage: Coverage$inboundSchema,
+  nation: z.nullable(NoisePointResponseNation$inboundSchema),
+  nations: z.array(NoiseNationCoverage$inboundSchema),
+  rail: NoiseSourceReadings$inboundSchema,
+  road: NoiseSourceReadings$inboundSchema,
+});
+
+export function noisePointResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<NoisePointResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NoisePointResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NoisePointResponse' from JSON`,
+  );
+}