@vepler/sdk 2.151.0 → 2.154.1

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

@@ -0,0 +1,53 @@
+/*
+ * 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 {
+  FloodRiskLevel,
+  FloodRiskLevel$inboundSchema,
+} from "./floodrisklevel.js";
+
+export const Direction = {
+  Increased: "increased",
+  Unchanged: "unchanged",
+  Decreased: "decreased",
+} as const;
+export type Direction = OpenEnum<typeof Direction>;
+
+export type FloodClimate2080 = {
+  direction: Direction;
+  projectedRiskLevel: FloodRiskLevel | null;
+};
+
+/** @internal */
+export const Direction$inboundSchema: z.ZodType<
+  Direction,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Direction);
+
+/** @internal */
+export const FloodClimate2080$inboundSchema: z.ZodType<
+  FloodClimate2080,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  direction: Direction$inboundSchema,
+  projectedRiskLevel: z.nullable(FloodRiskLevel$inboundSchema),
+});
+
+export function floodClimate2080FromJSON(
+  jsonString: string,
+): SafeParseResult<FloodClimate2080, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodClimate2080$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodClimate2080' from JSON`,
+  );
+}

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

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const FloodDataAvailability = {
+  Assessed: "assessed",
+  AssessedNoModelledRisk: "assessed_no_modelled_risk",
+  NotAssessed: "not_assessed",
+  OutOfCoverage: "out_of_coverage",
+  PartialQueryFailure: "partial_query_failure",
+} as const;
+export type FloodDataAvailability = OpenEnum<typeof FloodDataAvailability>;
+
+/** @internal */
+export const FloodDataAvailability$inboundSchema: z.ZodType<
+  FloodDataAvailability,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FloodDataAvailability);

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

@@ -0,0 +1,85 @@
+/*
+ * 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 {
+  FloodNearestDefence,
+  FloodNearestDefence$inboundSchema,
+} from "./floodnearestdefence.js";
+
+export const DefendsAgainst = {
+  River: "river",
+  Sea: "sea",
+} as const;
+export type DefendsAgainst = OpenEnum<typeof DefendsAgainst>;
+
+export type WithinDefendedArea = {
+  defendsAgainst: DefendsAgainst;
+  standardOfProtectionYears: number;
+};
+
+export type FloodDefence = {
+  hasDefencesNearby: boolean;
+  nearbyCount: number;
+  nearestDefence: FloodNearestDefence | null;
+  residualRiskNote: string;
+  withinDefendedArea: WithinDefendedArea | null;
+};
+
+/** @internal */
+export const DefendsAgainst$inboundSchema: z.ZodType<
+  DefendsAgainst,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(DefendsAgainst);
+
+/** @internal */
+export const WithinDefendedArea$inboundSchema: z.ZodType<
+  WithinDefendedArea,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  defendsAgainst: DefendsAgainst$inboundSchema,
+  standardOfProtectionYears: z.number(),
+});
+
+export function withinDefendedAreaFromJSON(
+  jsonString: string,
+): SafeParseResult<WithinDefendedArea, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WithinDefendedArea$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WithinDefendedArea' from JSON`,
+  );
+}
+
+/** @internal */
+export const FloodDefence$inboundSchema: z.ZodType<
+  FloodDefence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  hasDefencesNearby: z.boolean(),
+  nearbyCount: z.number().int(),
+  nearestDefence: z.nullable(FloodNearestDefence$inboundSchema),
+  residualRiskNote: z.string(),
+  withinDefendedArea: z.nullable(
+    z.lazy(() => WithinDefendedArea$inboundSchema),
+  ),
+});
+
+export function floodDefenceFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodDefence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodDefence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodDefence' from JSON`,
+  );
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const FloodHazardRating = {
+  Low: "low",
+  Moderate: "moderate",
+  Significant: "significant",
+  Extreme: "extreme",
+} as const;
+export type FloodHazardRating = OpenEnum<typeof FloodHazardRating>;
+
+/** @internal */
+export const FloodHazardRating$inboundSchema: z.ZodType<
+  FloodHazardRating,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FloodHazardRating);

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

@@ -0,0 +1,63 @@
+/*
+ * 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";
+
+export const FloodNearestDefenceCondition = {
+  Good: "good",
+  Fair: "fair",
+  Poor: "poor",
+  Unknown: "unknown",
+} as const;
+export type FloodNearestDefenceCondition = OpenEnum<
+  typeof FloodNearestDefenceCondition
+>;
+
+export type FloodNearestDefence = {
+  condition: FloodNearestDefenceCondition;
+  /**
+   * Asset type, e.g. 'Raised embankment' (never 'high_ground')
+   */
+  defenceType: string;
+  distanceMetres: number;
+  maintainedBy: string;
+  standardOfProtectionYears: number | null;
+  watercourseName: string | null;
+};
+
+/** @internal */
+export const FloodNearestDefenceCondition$inboundSchema: z.ZodType<
+  FloodNearestDefenceCondition,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FloodNearestDefenceCondition);
+
+/** @internal */
+export const FloodNearestDefence$inboundSchema: z.ZodType<
+  FloodNearestDefence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  condition: FloodNearestDefenceCondition$inboundSchema,
+  defenceType: z.string(),
+  distanceMetres: z.number(),
+  maintainedBy: z.string(),
+  standardOfProtectionYears: z.nullable(z.number()),
+  watercourseName: z.nullable(z.string()),
+});
+
+export function floodNearestDefenceFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodNearestDefence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodNearestDefence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodNearestDefence' from JSON`,
+  );
+}

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

@@ -0,0 +1,38 @@
+/*
+ * 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 { FloodZone, FloodZone$inboundSchema } from "./floodzone.js";
+
+export type FloodPlanning = {
+  exceptionTestMayApply: boolean;
+  floodZone: FloodZone;
+  fraRequired: boolean;
+  sequentialTestRequired: boolean;
+};
+
+/** @internal */
+export const FloodPlanning$inboundSchema: z.ZodType<
+  FloodPlanning,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  exceptionTestMayApply: z.boolean(),
+  floodZone: FloodZone$inboundSchema,
+  fraRequired: z.boolean(),
+  sequentialTestRequired: z.boolean(),
+});
+
+export function floodPlanningFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodPlanning, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodPlanning$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodPlanning' from JSON`,
+  );
+}

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

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const FloodPrimarySource = {
+  RiversSea: "rivers_sea",
+  SurfaceWater: "surface_water",
+} as const;
+export type FloodPrimarySource = OpenEnum<typeof FloodPrimarySource>;
+
+/** @internal */
+export const FloodPrimarySource$inboundSchema: z.ZodType<
+  FloodPrimarySource,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FloodPrimarySource);

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

@@ -0,0 +1,44 @@
+/*
+ * 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 FloodProbability = {
+  /**
+   * Annual chance as a percentage — e.g. 3.3 for a 1-in-30 year flood
+   */
+  annualPercentage: number;
+  /**
+   * Plain-English annual chance, e.g. 'about a 1-in-30 chance each year'
+   */
+  description: string;
+  /**
+   * Return period in years — e.g. 30 for a 1-in-30
+   */
+  returnPeriod: number;
+};
+
+/** @internal */
+export const FloodProbability$inboundSchema: z.ZodType<
+  FloodProbability,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  annualPercentage: z.number(),
+  description: z.string(),
+  returnPeriod: z.number(),
+});
+
+export function floodProbabilityFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodProbability, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodProbability$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodProbability' from JSON`,
+  );
+}

package/src/sdk/models/shared/floodriskcoordinate.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 FloodRiskCoordinate = {
+  /**
+   * Latitude in WGS84
+   */
+  lat: number;
+  /**
+   * Longitude in WGS84
+   */
+  lon: number;
+};
+
+/** @internal */
+export const FloodRiskCoordinate$inboundSchema: z.ZodType<
+  FloodRiskCoordinate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lon: z.number(),
+});
+/** @internal */
+export type FloodRiskCoordinate$Outbound = {
+  lat: number;
+  lon: number;
+};
+
+/** @internal */
+export const FloodRiskCoordinate$outboundSchema: z.ZodType<
+  FloodRiskCoordinate$Outbound,
+  z.ZodTypeDef,
+  FloodRiskCoordinate
+> = z.object({
+  lat: z.number(),
+  lon: z.number(),
+});
+
+export function floodRiskCoordinateToJSON(
+  floodRiskCoordinate: FloodRiskCoordinate,
+): string {
+  return JSON.stringify(
+    FloodRiskCoordinate$outboundSchema.parse(floodRiskCoordinate),
+  );
+}
+export function floodRiskCoordinateFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodRiskCoordinate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodRiskCoordinate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodRiskCoordinate' from JSON`,
+  );
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const FloodRiskLevel = {
+  VeryLow: "very_low",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+} as const;
+export type FloodRiskLevel = OpenEnum<typeof FloodRiskLevel>;
+
+/** @internal */
+export const FloodRiskLevel$inboundSchema: z.ZodType<
+  FloodRiskLevel,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FloodRiskLevel);

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

@@ -0,0 +1,82 @@
+/*
+ * 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 {
+  FloodClimate2080,
+  FloodClimate2080$inboundSchema,
+} from "./floodclimate2080.js";
+import {
+  FloodDataAvailability,
+  FloodDataAvailability$inboundSchema,
+} from "./flooddataavailability.js";
+import { FloodDefence, FloodDefence$inboundSchema } from "./flooddefence.js";
+import { FloodPlanning, FloodPlanning$inboundSchema } from "./floodplanning.js";
+import {
+  FloodRiskCoordinate,
+  FloodRiskCoordinate$inboundSchema,
+} from "./floodriskcoordinate.js";
+import {
+  FloodRiskSummary,
+  FloodRiskSummary$inboundSchema,
+} from "./floodrisksummary.js";
+import {
+  FloodRiversAndSeaRisk,
+  FloodRiversAndSeaRisk$inboundSchema,
+} from "./floodriversandsearisk.js";
+import {
+  FloodSurfaceWaterRisk,
+  FloodSurfaceWaterRisk$inboundSchema,
+} from "./floodsurfacewaterrisk.js";
+import { Provenance, Provenance$inboundSchema } from "./provenance.js";
+
+export type FloodRiskPoint = {
+  climate2080?: FloodClimate2080 | undefined;
+  coordinate: FloodRiskCoordinate;
+  dataAvailability: FloodDataAvailability;
+  defences?: FloodDefence | undefined;
+  /**
+   * Stable identifier for this assessment (cf. airQualityId)
+   */
+  floodRiskId: string;
+  planning?: FloodPlanning | undefined;
+  /**
+   * Universal provenance block — every product envelope carries this
+   */
+  provenance: Provenance;
+  riversAndSeaRisk: FloodRiversAndSeaRisk | null;
+  summary: FloodRiskSummary;
+  surfaceWaterRisk: FloodSurfaceWaterRisk | null;
+};
+
+/** @internal */
+export const FloodRiskPoint$inboundSchema: z.ZodType<
+  FloodRiskPoint,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  climate2080: FloodClimate2080$inboundSchema.optional(),
+  coordinate: FloodRiskCoordinate$inboundSchema,
+  dataAvailability: FloodDataAvailability$inboundSchema,
+  defences: FloodDefence$inboundSchema.optional(),
+  floodRiskId: z.string(),
+  planning: FloodPlanning$inboundSchema.optional(),
+  provenance: Provenance$inboundSchema,
+  riversAndSeaRisk: z.nullable(FloodRiversAndSeaRisk$inboundSchema),
+  summary: FloodRiskSummary$inboundSchema,
+  surfaceWaterRisk: z.nullable(FloodSurfaceWaterRisk$inboundSchema),
+});
+
+export function floodRiskPointFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodRiskPoint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodRiskPoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodRiskPoint' from JSON`,
+  );
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  FloodRiskCoordinate,
+  FloodRiskCoordinate$Outbound,
+  FloodRiskCoordinate$outboundSchema,
+} from "./floodriskcoordinate.js";
+import {
+  FloodScenario,
+  FloodScenario$outboundSchema,
+} from "./floodscenario.js";
+
+export type FloodRiskPointRequest = {
+  coordinate: FloodRiskCoordinate;
+  /**
+   * Which scenarios to assess: present day, climate-change 2080, or both.
+   */
+  scenario?: FloodScenario | undefined;
+  /**
+   * Enable billing tracking telemetry
+   */
+  track?: boolean | undefined;
+};
+
+/** @internal */
+export type FloodRiskPointRequest$Outbound = {
+  coordinate: FloodRiskCoordinate$Outbound;
+  scenario: string;
+  track: boolean;
+};
+
+/** @internal */
+export const FloodRiskPointRequest$outboundSchema: z.ZodType<
+  FloodRiskPointRequest$Outbound,
+  z.ZodTypeDef,
+  FloodRiskPointRequest
+> = z.object({
+  coordinate: FloodRiskCoordinate$outboundSchema,
+  scenario: FloodScenario$outboundSchema.default("both"),
+  track: z.boolean().default(false),
+});
+
+export function floodRiskPointRequestToJSON(
+  floodRiskPointRequest: FloodRiskPointRequest,
+): string {
+  return JSON.stringify(
+    FloodRiskPointRequest$outboundSchema.parse(floodRiskPointRequest),
+  );
+}

package/src/sdk/models/shared/floodrisksummary.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 * 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 {
+  FloodPrimarySource,
+  FloodPrimarySource$inboundSchema,
+} from "./floodprimarysource.js";
+import {
+  FloodRiskLevel,
+  FloodRiskLevel$inboundSchema,
+} from "./floodrisklevel.js";
+
+export const CountryCode = {
+  Eng: "ENG",
+  Sco: "SCO",
+  Wal: "WAL",
+} as const;
+export type CountryCode = OpenEnum<typeof CountryCode>;
+
+export type FloodRiskSummary = {
+  countryCode: CountryCode | null;
+  label: string;
+  overallRiskLevel: FloodRiskLevel | null;
+  primarySource: FloodPrimarySource | null;
+};
+
+/** @internal */
+export const CountryCode$inboundSchema: z.ZodType<
+  CountryCode,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CountryCode);
+
+/** @internal */
+export const FloodRiskSummary$inboundSchema: z.ZodType<
+  FloodRiskSummary,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  countryCode: z.nullable(CountryCode$inboundSchema),
+  label: z.string(),
+  overallRiskLevel: z.nullable(FloodRiskLevel$inboundSchema),
+  primarySource: z.nullable(FloodPrimarySource$inboundSchema),
+});
+
+export function floodRiskSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodRiskSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodRiskSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodRiskSummary' from JSON`,
+  );
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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 {
+  FloodProbability,
+  FloodProbability$inboundSchema,
+} from "./floodprobability.js";
+import {
+  FloodRiskLevel,
+  FloodRiskLevel$inboundSchema,
+} from "./floodrisklevel.js";
+
+export type FloodRiversAndSeaRisk = {
+  /**
+   * Plain-English depth impact, e.g. 'Waist deep — significant property damage likely'
+   */
+  depthImpact: string | null;
+  /**
+   * Maximum modelled flood depth in metres, or null if not modelled here
+   */
+  maxDepthMetres: number | null;
+  probability?: FloodProbability | undefined;
+  riskLevel: FloodRiskLevel | null;
+};
+
+/** @internal */
+export const FloodRiversAndSeaRisk$inboundSchema: z.ZodType<
+  FloodRiversAndSeaRisk,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  depthImpact: z.nullable(z.string()),
+  maxDepthMetres: z.nullable(z.number()),
+  probability: FloodProbability$inboundSchema.optional(),
+  riskLevel: z.nullable(FloodRiskLevel$inboundSchema),
+});
+
+export function floodRiversAndSeaRiskFromJSON(
+  jsonString: string,
+): SafeParseResult<FloodRiversAndSeaRisk, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FloodRiversAndSeaRisk$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FloodRiversAndSeaRisk' from JSON`,
+  );
+}