@vepler/sdk 2.149.0 → 2.152.0

package/src/sdk/models/operations/queryschoolsbysource.ts

@@ -11,6 +11,11 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as shared from "../shared/index.js";
 
+/**
+ * Fields/blocks to return per school. Default (omitted): the full flat record, no blocks. Aggregate blocks (`inspections`, `identifiers`, `trust`) are additive — requesting only block names keeps the full flat record and adds the blocks. List scalar field names to trim.
+ */
+export type Attributes = string | Array<string>;
+
 /**
  * Source register identifier. 'dfe': UK DfE GIAS (England + cross-border Welsh URNs). 'welshgov': Welsh Government School Number. 'seed': Scottish SEED code. 'deni': NI DE Reference. 'dept_edu_ie': Irish Roll Number.
  */
@@ -30,6 +35,10 @@ export type Provider = ClosedEnum<typeof Provider>;
  * Batch lookup by provider keys. Keys that do not match are silently omitted from the response.
  */
 export type QuerySchoolsBySourceRequestBody = {
+  /**
+   * Fields/blocks to return per school. Default (omitted): the full flat record, no blocks. Aggregate blocks (`inspections`, `identifiers`, `trust`) are additive — requesting only block names keeps the full flat record and adds the blocks. List scalar field names to trim.
+   */
+  attributes?: string | Array<string> | undefined;
   /**
    * Array of provider-scoped identifiers (URNs / SEED codes / etc). Maximum 500 per request.
    */
@@ -97,6 +106,42 @@ export type QuerySchoolsBySourceCurrentRating = OpenEnum<
   typeof QuerySchoolsBySourceCurrentRating
 >;
 
+/**
+ * Cross-register identifiers. Present only when requested via `attributes=identifiers`.
+ */
+export type QuerySchoolsBySourceIdentifiers = {
+  /**
+   * Estyn provider id (Wales).
+   */
+  estynId?: string | null | undefined;
+  /**
+   * Ofsted provider id (England).
+   */
+  ofstedProviderId?: string | null | undefined;
+  /**
+   * Predecessor URNs this school was previously known by (re-identification lineage).
+   */
+  oldUrns?: Array<string> | undefined;
+  /**
+   * UK Provider Reference Number (UKPRN).
+   */
+  ukprn?: string | null | undefined;
+};
+
+/**
+ * Inspection history. Present only when requested via `attributes=inspections`.
+ */
+export type QuerySchoolsBySourceInspections = {
+  /**
+   * Most recent inspection event, or null if never inspected.
+   */
+  current: shared.SchoolInspectionEvent | null;
+  /**
+   * Every inspection event, newest first (includes `current`).
+   */
+  history?: Array<shared.SchoolInspectionEvent | null> | undefined;
+};
+
 /**
  * Geographic coordinates of the school
  */
@@ -156,6 +201,16 @@ export type QuerySchoolsBySourceStatus = OpenEnum<
   typeof QuerySchoolsBySourceStatus
 >;
 
+/**
+ * Trust / organisation memberships. Present only when requested via `attributes=trust`.
+ */
+export type QuerySchoolsBySourceTrust = {
+  /**
+   * Active organisation memberships, lead/trust roles first.
+   */
+  memberships?: Array<shared.SchoolTrustMembership> | undefined;
+};
+
 /**
  * Educational institution type. 'nursery': early years. 'primary': key stages 1-2 / ISCED 1. 'secondary': key stages 3-4 / ISCED 2-3. 'all-through': combined primary + secondary. 'sixth-form': post-16. 'special': special educational needs. 'independent': fee-paying. 'academy': state-funded, independently run. 'other': alternative provision / pupil referral / unclassified.
  */
@@ -215,6 +270,14 @@ export type QuerySchoolsBySourceData = {
    * System-generated identifier. Stable across updates.
    */
   id: number;
+  /**
+   * Cross-register identifiers. Present only when requested via `attributes=identifiers`.
+   */
+  identifiers?: QuerySchoolsBySourceIdentifiers | null | undefined;
+  /**
+   * Inspection history. Present only when requested via `attributes=inspections`.
+   */
+  inspections?: QuerySchoolsBySourceInspections | null | undefined;
   /**
    * Provider-scoped identifier. URN for `dfe`, SEED for `seed`, etc. Combined with `provider` this is a globally unique alternate key for the school.
    */
@@ -271,6 +334,10 @@ export type QuerySchoolsBySourceData = {
    */
   subType?: string | undefined;
   telephone?: string | undefined;
+  /**
+   * Trust / organisation memberships. Present only when requested via `attributes=trust`.
+   */
+  trust?: QuerySchoolsBySourceTrust | null | undefined;
   trustId?: string | undefined;
   trustName?: string | undefined;
   /**
@@ -323,12 +390,27 @@ export type QuerySchoolsBySourceResponseBody = {
   url: string;
 };
 
+/** @internal */
+export type Attributes$Outbound = string | Array<string>;
+
+/** @internal */
+export const Attributes$outboundSchema: z.ZodType<
+  Attributes$Outbound,
+  z.ZodTypeDef,
+  Attributes
+> = z.union([z.string(), z.array(z.string())]);
+
+export function attributesToJSON(attributes: Attributes): string {
+  return JSON.stringify(Attributes$outboundSchema.parse(attributes));
+}
+
 /** @internal */
 export const Provider$outboundSchema: z.ZodNativeEnum<typeof Provider> = z
   .nativeEnum(Provider);
 
 /** @internal */
 export type QuerySchoolsBySourceRequestBody$Outbound = {
+  attributes?: string | Array<string> | undefined;
   keys: Array<string>;
   provider: string;
 };
@@ -339,6 +421,7 @@ export const QuerySchoolsBySourceRequestBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   QuerySchoolsBySourceRequestBody
 > = z.object({
+  attributes: z.union([z.string(), z.array(z.string())]).optional(),
   keys: z.array(z.string()),
   provider: Provider$outboundSchema,
 });
@@ -383,6 +466,49 @@ export const QuerySchoolsBySourceCurrentRating$inboundSchema: z.ZodType<
   unknown
 > = openEnums.inboundSchema(QuerySchoolsBySourceCurrentRating);
 
+/** @internal */
+export const QuerySchoolsBySourceIdentifiers$inboundSchema: z.ZodType<
+  QuerySchoolsBySourceIdentifiers,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  estynId: z.nullable(z.string()).optional(),
+  ofstedProviderId: z.nullable(z.string()).optional(),
+  oldUrns: z.array(z.string()).optional(),
+  ukprn: z.nullable(z.string()).optional(),
+});
+
+export function querySchoolsBySourceIdentifiersFromJSON(
+  jsonString: string,
+): SafeParseResult<QuerySchoolsBySourceIdentifiers, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QuerySchoolsBySourceIdentifiers$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QuerySchoolsBySourceIdentifiers' from JSON`,
+  );
+}
+
+/** @internal */
+export const QuerySchoolsBySourceInspections$inboundSchema: z.ZodType<
+  QuerySchoolsBySourceInspections,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  current: z.nullable(shared.SchoolInspectionEvent$inboundSchema),
+  history: z.array(z.nullable(shared.SchoolInspectionEvent$inboundSchema))
+    .optional(),
+});
+
+export function querySchoolsBySourceInspectionsFromJSON(
+  jsonString: string,
+): SafeParseResult<QuerySchoolsBySourceInspections, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QuerySchoolsBySourceInspections$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QuerySchoolsBySourceInspections' from JSON`,
+  );
+}
+
 /** @internal */
 export const QuerySchoolsBySourceLocation$inboundSchema: z.ZodType<
   QuerySchoolsBySourceLocation,
@@ -422,6 +548,25 @@ export const QuerySchoolsBySourceStatus$inboundSchema: z.ZodType<
   unknown
 > = openEnums.inboundSchema(QuerySchoolsBySourceStatus);
 
+/** @internal */
+export const QuerySchoolsBySourceTrust$inboundSchema: z.ZodType<
+  QuerySchoolsBySourceTrust,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  memberships: z.array(shared.SchoolTrustMembership$inboundSchema).optional(),
+});
+
+export function querySchoolsBySourceTrustFromJSON(
+  jsonString: string,
+): SafeParseResult<QuerySchoolsBySourceTrust, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QuerySchoolsBySourceTrust$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QuerySchoolsBySourceTrust' from JSON`,
+  );
+}
+
 /** @internal */
 export const QuerySchoolsBySourceType$inboundSchema: z.ZodType<
   QuerySchoolsBySourceType,
@@ -449,6 +594,12 @@ export const QuerySchoolsBySourceData$inboundSchema: z.ZodType<
   gender: z.string().optional(),
   headteacher: z.string().optional(),
   id: z.number().int(),
+  identifiers: z.nullable(
+    z.lazy(() => QuerySchoolsBySourceIdentifiers$inboundSchema),
+  ).optional(),
+  inspections: z.nullable(
+    z.lazy(() => QuerySchoolsBySourceInspections$inboundSchema),
+  ).optional(),
   key: z.string(),
   laCode: z.string().optional(),
   laName: z.string().optional(),
@@ -470,6 +621,8 @@ export const QuerySchoolsBySourceData$inboundSchema: z.ZodType<
   status: QuerySchoolsBySourceStatus$inboundSchema,
   subType: z.string().optional(),
   telephone: z.string().optional(),
+  trust: z.nullable(z.lazy(() => QuerySchoolsBySourceTrust$inboundSchema))
+    .optional(),
   trustId: z.string().optional(),
   trustName: z.string().optional(),
   type: QuerySchoolsBySourceType$inboundSchema,

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

@@ -33,7 +33,7 @@ export type ChargeEntry = {
    */
   sourceProvider: string;
   /**
-   * Charge amount in pence
+   * Charge amount in GBP (whole pounds)
    */
   value: number;
 };

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

@@ -18,7 +18,7 @@ export type ChargeHistory = {
    */
   currency?: string | null | undefined;
   /**
-   * Current best estimate (annual) in pence
+   * Current best estimate (annual) in GBP (whole pounds)
    */
   current?: number | null | undefined;
   /**

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`,
+  );
+}