@vepler/sdk 2.8.0 → 2.9.0

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

@@ -0,0 +1,1062 @@
+/*
+ * 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";
+
+export type Coordinates = {
+  lat: number;
+  lon: number;
+};
+
+export const Method = {
+  ElasticsearchExact: "elasticsearch-exact",
+  ElasticsearchPartial: "elasticsearch-partial",
+  ElasticsearchFuzzy: "elasticsearch-fuzzy",
+  ElasticsearchDirect: "elasticsearch-direct",
+  PostcodeFallback: "postcode-fallback",
+  SpatialMatch: "spatial-match",
+  SpatialNarrative: "spatial-narrative",
+  Unmatched: "unmatched",
+} as const;
+export type Method = ClosedEnum<typeof Method>;
+
+export type AddressResolution = {
+  canonicalAddress?: string | undefined;
+  confidence: number;
+  coordinates?: Coordinates | undefined;
+  input: string;
+  matched: boolean;
+  method: Method;
+  processingSteps?: Array<string> | undefined;
+  uprn?: string | undefined;
+};
+
+export const Severity = {
+  Critical: "critical",
+  Warning: "warning",
+  Info: "info",
+} as const;
+export type Severity = ClosedEnum<typeof Severity>;
+
+export type Checks = {
+  details: string;
+  name: string;
+  passed: boolean;
+  severity?: Severity | undefined;
+};
+
+export const RoaVerifyResponseVerdict = {
+  Pass: "PASS",
+  Warning: "WARNING",
+  Fail: "FAIL",
+} as const;
+export type RoaVerifyResponseVerdict = ClosedEnum<
+  typeof RoaVerifyResponseVerdict
+>;
+
+export type Appropriateness = {
+  checks: Array<Checks>;
+  score: number;
+  summary: string;
+  verdict: RoaVerifyResponseVerdict;
+};
+
+export type ConcentrationMetrics = {
+  averageForPropertyType: number;
+  companiesAtBuilding?: number | undefined;
+  companiesAtPostcode: number;
+  companiesAtUPRN: number;
+  percentileRank?: number | undefined;
+};
+
+export const Impact = {
+  None: "none",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+} as const;
+export type Impact = ClosedEnum<typeof Impact>;
+
+export const Risk = {
+  None: "none",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+} as const;
+export type Risk = ClosedEnum<typeof Risk>;
+
+export type RoaVerifyResponseValue = number | boolean | string;
+
+export type RoaVerifyResponseFeatures = {
+  description: string;
+  impact?: Impact | undefined;
+  name: string;
+  risk: Risk;
+  threshold?: number | undefined;
+  value: number | boolean | string;
+};
+
+export const RecommendedAction = {
+  Approve: "APPROVE",
+  Review: "REVIEW",
+  Reject: "REJECT",
+} as const;
+export type RecommendedAction = ClosedEnum<typeof RecommendedAction>;
+
+export const RiskBand = {
+  Low: "LOW",
+  Medium: "MEDIUM",
+  High: "HIGH",
+  Critical: "CRITICAL",
+} as const;
+export type RiskBand = ClosedEnum<typeof RiskBand>;
+
+export type FraudRisk = {
+  concentrationMetrics: ConcentrationMetrics;
+  features: Array<RoaVerifyResponseFeatures>;
+  overallScore: number;
+  recommendedAction: RecommendedAction;
+  riskBand: RiskBand;
+  topReasons: Array<string>;
+};
+
+export type AddressMatch = {
+  /**
+   * Confidence score of address match
+   */
+  confidence: number;
+  /**
+   * Details of match or mismatch
+   */
+  details: string;
+  /**
+   * Proprietor address matches registered office address
+   */
+  matched: boolean;
+};
+
+/**
+ * Method used for identity verification
+ */
+export const RoaVerifyResponseVerificationMethod = {
+  GovUkOneLogin: "gov-uk-one-login",
+  Acsp: "acsp",
+  NotVerified: "not-verified",
+} as const;
+/**
+ * Method used for identity verification
+ */
+export type RoaVerifyResponseVerificationMethod = ClosedEnum<
+  typeof RoaVerifyResponseVerificationMethod
+>;
+
+/**
+ * The director/PSC submitting the ROA
+ */
+export type FilingOfficer = {
+  /**
+   * Identity verified through Companies House (GOV.UK One Login or ACSP)
+   */
+  companiesHouseVerified: boolean;
+  /**
+   * Whether this person is registered as proprietor on Land Registry title deed
+   */
+  isProprietor: boolean;
+  /**
+   * Name of director/PSC filing the ROA or making the submission
+   */
+  name: string;
+  /**
+   * Role in company (e.g., Director, PSC, Secretary)
+   */
+  role: string;
+  /**
+   * Date identity was verified
+   */
+  verificationDate?: string | undefined;
+  /**
+   * Method used for identity verification
+   */
+  verificationMethod: RoaVerifyResponseVerificationMethod;
+};
+
+export type NameMatch = {
+  /**
+   * Confidence score of name match
+   */
+  confidence: number;
+  /**
+   * Details of match or mismatch
+   */
+  details: string;
+  /**
+   * Name on title deed matches verified identity
+   */
+  matched: boolean;
+};
+
+/**
+ * Method used for identity verification
+ */
+export const VerificationMethod = {
+  GovUkOneLogin: "gov-uk-one-login",
+  Acsp: "acsp",
+  NotVerified: "not-verified",
+} as const;
+/**
+ * Method used for identity verification
+ */
+export type VerificationMethod = ClosedEnum<typeof VerificationMethod>;
+
+/**
+ * Match between Companies House verified identity and title deed
+ */
+export type IdentityMatch = {
+  addressMatch: AddressMatch;
+  /**
+   * Identity verified through Companies House (GOV.UK One Login or ACSP)
+   */
+  companiesHouseVerified: boolean;
+  /**
+   * The director/PSC submitting the ROA
+   */
+  filingOfficer?: FilingOfficer | undefined;
+  nameMatch: NameMatch;
+  /**
+   * Date identity was verified
+   */
+  verificationDate?: string | undefined;
+  /**
+   * Method used for identity verification
+   */
+  verificationMethod: VerificationMethod;
+};
+
+export type Proprietors = {
+  /**
+   * Proprietor address from Title Register
+   */
+  address?: string | undefined;
+  /**
+   * Company registration number if company proprietor
+   */
+  companyNumber?: string | undefined;
+  /**
+   * Date proprietorship registered
+   */
+  dateRegistered?: string | undefined;
+  /**
+   * Registered proprietor name from Title Register
+   */
+  name: string;
+};
+
+/**
+ * Type of tenure
+ */
+export const TenureType = {
+  Freehold: "freehold",
+  Leasehold: "leasehold",
+  Unknown: "unknown",
+} as const;
+/**
+ * Type of tenure
+ */
+export type TenureType = ClosedEnum<typeof TenureType>;
+
+/**
+ * Status of Land Registry verification
+ */
+export const VerificationStatus = {
+  Verified: "verified",
+  Partial: "partial",
+  NotVerified: "not-verified",
+  Unavailable: "unavailable",
+} as const;
+/**
+ * Status of Land Registry verification
+ */
+export type VerificationStatus = ClosedEnum<typeof VerificationStatus>;
+
+export type LandRegistryVerification = {
+  /**
+   * Land Registry title deed data available
+   */
+  available: boolean;
+  /**
+   * Any flags or concerns from Land Registry check
+   */
+  flags?: Array<string> | undefined;
+  /**
+   * Match between Companies House verified identity and title deed
+   */
+  identityMatch?: IdentityMatch | undefined;
+  /**
+   * Registered proprietors from Title Register
+   */
+  proprietors?: Array<Proprietors> | undefined;
+  /**
+   * Summary of Land Registry verification
+   */
+  summary: string;
+  /**
+   * Type of tenure
+   */
+  tenureType?: TenureType | undefined;
+  /**
+   * HM Land Registry title number
+   */
+  titleNumber?: string | undefined;
+  /**
+   * Overall Land Registry verification score
+   */
+  verificationScore: number;
+  /**
+   * Status of Land Registry verification
+   */
+  verificationStatus: VerificationStatus;
+};
+
+export type DataSources = {
+  /**
+   * Companies House API was available and used for company data
+   */
+  companiesHouse: boolean;
+  /**
+   * Elasticsearch was used for property characteristics
+   */
+  elasticsearch: boolean;
+  /**
+   * OS NGD API was available and used for property classification
+   */
+  osNgd: boolean;
+};
+
+export type ModelVersions = {
+  fraudModel: string;
+  rules: string;
+};
+
+/**
+ * OS NGD building and address data when available
+ */
+export type OsNgdData = {
+  /**
+   * Number of addresses in building (serviced office indicator)
+   */
+  addressCount?: number | undefined;
+  /**
+   * OS NGD address feature type (Built, Pre-Build, Non-Addressable, etc.)
+   */
+  addressType?: string | undefined;
+  /**
+   * Building age/construction period
+   */
+  buildingAge?: string | undefined;
+  /**
+   * Number of floors in building
+   */
+  buildingFloors?: number | undefined;
+  /**
+   * Building has green roof
+   */
+  hasGreenRoof?: boolean | undefined;
+  /**
+   * Building has solar panels
+   */
+  hasSolarPanels?: boolean | undefined;
+  /**
+   * OS NGD land use classification (Residential, Commercial, Office, etc.)
+   */
+  landUse?: string | undefined;
+};
+
+export type Metadata = {
+  dataSources: DataSources;
+  modelVersions: ModelVersions;
+  /**
+   * OS NGD building and address data when available
+   */
+  osNgdData?: OsNgdData | undefined;
+  processingTimeMs: number;
+  timestamp: string;
+  verificationId?: string | undefined;
+};
+
+export const OwnershipType = {
+  Individual: "individual",
+  Company: "company",
+  Public: "public",
+  Unknown: "unknown",
+} as const;
+export type OwnershipType = ClosedEnum<typeof OwnershipType>;
+
+export type PropertyData = {
+  bathrooms?: number | null | undefined;
+  bedrooms?: number | null | undefined;
+  buildDate?: string | null | undefined;
+  councilTaxBand?: string | null | undefined;
+  currentOwner?: string | null | undefined;
+  epcRating?: string | null | undefined;
+  floorArea?: number | null | undefined;
+  ownershipType?: OwnershipType | null | undefined;
+  propertyType?: string | null | undefined;
+  tenure?: string | null | undefined;
+  uprn: string;
+};
+
+export const Likelihood = {
+  Unknown: "UNKNOWN",
+  Low: "LOW",
+  Medium: "MEDIUM",
+  High: "HIGH",
+} as const;
+export type Likelihood = ClosedEnum<typeof Likelihood>;
+
+export type Signals = {
+  confidence?: number | undefined;
+  details: string;
+  found: boolean;
+  name: string;
+};
+
+export type RightToUse = {
+  confidence: number;
+  likelihood: Likelihood;
+  reasoning: Array<string>;
+  signals: Array<Signals>;
+  summary: string;
+};
+
+export const Decision = {
+  Pass: "PASS",
+  PassWithFlag: "PASS_WITH_FLAG",
+  Fail: "FAIL",
+} as const;
+export type Decision = ClosedEnum<typeof Decision>;
+
+export const RoaVerifyResponseRecommendedAction = {
+  Approve: "APPROVE",
+  ManualReview: "MANUAL_REVIEW",
+  Reject: "REJECT",
+} as const;
+export type RoaVerifyResponseRecommendedAction = ClosedEnum<
+  typeof RoaVerifyResponseRecommendedAction
+>;
+
+export type Verdict = {
+  confidence: number;
+  criticalIssues?: Array<string> | undefined;
+  decision: Decision;
+  flags: Array<string>;
+  recommendedAction: RoaVerifyResponseRecommendedAction;
+  summary: string;
+};
+
+export type RoaVerifyResponse = {
+  addressResolution: AddressResolution;
+  appropriateness: Appropriateness;
+  fraudRisk: FraudRisk;
+  landRegistryVerification: LandRegistryVerification;
+  metadata: Metadata;
+  propertyData?: PropertyData | undefined;
+  rightToUse: RightToUse;
+  verdict: Verdict;
+};
+
+/** @internal */
+export const Coordinates$inboundSchema: z.ZodType<
+  Coordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lon: z.number(),
+});
+
+export function coordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<Coordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Coordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Coordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const Method$inboundSchema: z.ZodNativeEnum<typeof Method> = z
+  .nativeEnum(Method);
+
+/** @internal */
+export const AddressResolution$inboundSchema: z.ZodType<
+  AddressResolution,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  canonicalAddress: z.string().optional(),
+  confidence: z.number(),
+  coordinates: z.lazy(() => Coordinates$inboundSchema).optional(),
+  input: z.string(),
+  matched: z.boolean(),
+  method: Method$inboundSchema,
+  processingSteps: z.array(z.string()).optional(),
+  uprn: z.string().optional(),
+});
+
+export function addressResolutionFromJSON(
+  jsonString: string,
+): SafeParseResult<AddressResolution, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddressResolution$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddressResolution' from JSON`,
+  );
+}
+
+/** @internal */
+export const Severity$inboundSchema: z.ZodNativeEnum<typeof Severity> = z
+  .nativeEnum(Severity);
+
+/** @internal */
+export const Checks$inboundSchema: z.ZodType<Checks, z.ZodTypeDef, unknown> = z
+  .object({
+    details: z.string(),
+    name: z.string(),
+    passed: z.boolean(),
+    severity: Severity$inboundSchema.default("info"),
+  });
+
+export function checksFromJSON(
+  jsonString: string,
+): SafeParseResult<Checks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Checks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Checks' from JSON`,
+  );
+}
+
+/** @internal */
+export const RoaVerifyResponseVerdict$inboundSchema: z.ZodNativeEnum<
+  typeof RoaVerifyResponseVerdict
+> = z.nativeEnum(RoaVerifyResponseVerdict);
+
+/** @internal */
+export const Appropriateness$inboundSchema: z.ZodType<
+  Appropriateness,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  checks: z.array(z.lazy(() => Checks$inboundSchema)),
+  score: z.number(),
+  summary: z.string(),
+  verdict: RoaVerifyResponseVerdict$inboundSchema,
+});
+
+export function appropriatenessFromJSON(
+  jsonString: string,
+): SafeParseResult<Appropriateness, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Appropriateness$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Appropriateness' from JSON`,
+  );
+}
+
+/** @internal */
+export const ConcentrationMetrics$inboundSchema: z.ZodType<
+  ConcentrationMetrics,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  averageForPropertyType: z.number(),
+  companiesAtBuilding: z.number().optional(),
+  companiesAtPostcode: z.number(),
+  companiesAtUPRN: z.number(),
+  percentileRank: z.number().optional(),
+});
+
+export function concentrationMetricsFromJSON(
+  jsonString: string,
+): SafeParseResult<ConcentrationMetrics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConcentrationMetrics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConcentrationMetrics' from JSON`,
+  );
+}
+
+/** @internal */
+export const Impact$inboundSchema: z.ZodNativeEnum<typeof Impact> = z
+  .nativeEnum(Impact);
+
+/** @internal */
+export const Risk$inboundSchema: z.ZodNativeEnum<typeof Risk> = z.nativeEnum(
+  Risk,
+);
+
+/** @internal */
+export const RoaVerifyResponseValue$inboundSchema: z.ZodType<
+  RoaVerifyResponseValue,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.number(), z.boolean(), z.string()]);
+
+export function roaVerifyResponseValueFromJSON(
+  jsonString: string,
+): SafeParseResult<RoaVerifyResponseValue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RoaVerifyResponseValue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RoaVerifyResponseValue' from JSON`,
+  );
+}
+
+/** @internal */
+export const RoaVerifyResponseFeatures$inboundSchema: z.ZodType<
+  RoaVerifyResponseFeatures,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  description: z.string(),
+  impact: Impact$inboundSchema.optional(),
+  name: z.string(),
+  risk: Risk$inboundSchema,
+  threshold: z.number().optional(),
+  value: z.union([z.number(), z.boolean(), z.string()]),
+});
+
+export function roaVerifyResponseFeaturesFromJSON(
+  jsonString: string,
+): SafeParseResult<RoaVerifyResponseFeatures, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RoaVerifyResponseFeatures$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RoaVerifyResponseFeatures' from JSON`,
+  );
+}
+
+/** @internal */
+export const RecommendedAction$inboundSchema: z.ZodNativeEnum<
+  typeof RecommendedAction
+> = z.nativeEnum(RecommendedAction);
+
+/** @internal */
+export const RiskBand$inboundSchema: z.ZodNativeEnum<typeof RiskBand> = z
+  .nativeEnum(RiskBand);
+
+/** @internal */
+export const FraudRisk$inboundSchema: z.ZodType<
+  FraudRisk,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  concentrationMetrics: z.lazy(() => ConcentrationMetrics$inboundSchema),
+  features: z.array(z.lazy(() => RoaVerifyResponseFeatures$inboundSchema)),
+  overallScore: z.number(),
+  recommendedAction: RecommendedAction$inboundSchema,
+  riskBand: RiskBand$inboundSchema,
+  topReasons: z.array(z.string()),
+});
+
+export function fraudRiskFromJSON(
+  jsonString: string,
+): SafeParseResult<FraudRisk, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FraudRisk$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FraudRisk' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddressMatch$inboundSchema: z.ZodType<
+  AddressMatch,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number(),
+  details: z.string(),
+  matched: z.boolean(),
+});
+
+export function addressMatchFromJSON(
+  jsonString: string,
+): SafeParseResult<AddressMatch, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddressMatch$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddressMatch' from JSON`,
+  );
+}
+
+/** @internal */
+export const RoaVerifyResponseVerificationMethod$inboundSchema: z.ZodNativeEnum<
+  typeof RoaVerifyResponseVerificationMethod
+> = z.nativeEnum(RoaVerifyResponseVerificationMethod);
+
+/** @internal */
+export const FilingOfficer$inboundSchema: z.ZodType<
+  FilingOfficer,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  companiesHouseVerified: z.boolean(),
+  isProprietor: z.boolean(),
+  name: z.string(),
+  role: z.string(),
+  verificationDate: z.string().optional(),
+  verificationMethod: RoaVerifyResponseVerificationMethod$inboundSchema,
+});
+
+export function filingOfficerFromJSON(
+  jsonString: string,
+): SafeParseResult<FilingOfficer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FilingOfficer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FilingOfficer' from JSON`,
+  );
+}
+
+/** @internal */
+export const NameMatch$inboundSchema: z.ZodType<
+  NameMatch,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number(),
+  details: z.string(),
+  matched: z.boolean(),
+});
+
+export function nameMatchFromJSON(
+  jsonString: string,
+): SafeParseResult<NameMatch, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => NameMatch$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NameMatch' from JSON`,
+  );
+}
+
+/** @internal */
+export const VerificationMethod$inboundSchema: z.ZodNativeEnum<
+  typeof VerificationMethod
+> = z.nativeEnum(VerificationMethod);
+
+/** @internal */
+export const IdentityMatch$inboundSchema: z.ZodType<
+  IdentityMatch,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  addressMatch: z.lazy(() => AddressMatch$inboundSchema),
+  companiesHouseVerified: z.boolean(),
+  filingOfficer: z.lazy(() => FilingOfficer$inboundSchema).optional(),
+  nameMatch: z.lazy(() => NameMatch$inboundSchema),
+  verificationDate: z.string().optional(),
+  verificationMethod: VerificationMethod$inboundSchema,
+});
+
+export function identityMatchFromJSON(
+  jsonString: string,
+): SafeParseResult<IdentityMatch, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IdentityMatch$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IdentityMatch' from JSON`,
+  );
+}
+
+/** @internal */
+export const Proprietors$inboundSchema: z.ZodType<
+  Proprietors,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  address: z.string().optional(),
+  companyNumber: z.string().optional(),
+  dateRegistered: z.string().optional(),
+  name: z.string(),
+});
+
+export function proprietorsFromJSON(
+  jsonString: string,
+): SafeParseResult<Proprietors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Proprietors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Proprietors' from JSON`,
+  );
+}
+
+/** @internal */
+export const TenureType$inboundSchema: z.ZodNativeEnum<typeof TenureType> = z
+  .nativeEnum(TenureType);
+
+/** @internal */
+export const VerificationStatus$inboundSchema: z.ZodNativeEnum<
+  typeof VerificationStatus
+> = z.nativeEnum(VerificationStatus);
+
+/** @internal */
+export const LandRegistryVerification$inboundSchema: z.ZodType<
+  LandRegistryVerification,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  available: z.boolean(),
+  flags: z.array(z.string()).optional(),
+  identityMatch: z.lazy(() => IdentityMatch$inboundSchema).optional(),
+  proprietors: z.array(z.lazy(() => Proprietors$inboundSchema)).optional(),
+  summary: z.string(),
+  tenureType: TenureType$inboundSchema.optional(),
+  titleNumber: z.string().optional(),
+  verificationScore: z.number(),
+  verificationStatus: VerificationStatus$inboundSchema,
+});
+
+export function landRegistryVerificationFromJSON(
+  jsonString: string,
+): SafeParseResult<LandRegistryVerification, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LandRegistryVerification$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LandRegistryVerification' from JSON`,
+  );
+}
+
+/** @internal */
+export const DataSources$inboundSchema: z.ZodType<
+  DataSources,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  companiesHouse: z.boolean(),
+  elasticsearch: z.boolean(),
+  osNgd: z.boolean(),
+});
+
+export function dataSourcesFromJSON(
+  jsonString: string,
+): SafeParseResult<DataSources, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataSources$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataSources' from JSON`,
+  );
+}
+
+/** @internal */
+export const ModelVersions$inboundSchema: z.ZodType<
+  ModelVersions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  fraudModel: z.string(),
+  rules: z.string(),
+});
+
+export function modelVersionsFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelVersions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelVersions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelVersions' from JSON`,
+  );
+}
+
+/** @internal */
+export const OsNgdData$inboundSchema: z.ZodType<
+  OsNgdData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  addressCount: z.number().optional(),
+  addressType: z.string().optional(),
+  buildingAge: z.string().optional(),
+  buildingFloors: z.number().optional(),
+  hasGreenRoof: z.boolean().optional(),
+  hasSolarPanels: z.boolean().optional(),
+  landUse: z.string().optional(),
+});
+
+export function osNgdDataFromJSON(
+  jsonString: string,
+): SafeParseResult<OsNgdData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OsNgdData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OsNgdData' from JSON`,
+  );
+}
+
+/** @internal */
+export const Metadata$inboundSchema: z.ZodType<
+  Metadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  dataSources: z.lazy(() => DataSources$inboundSchema),
+  modelVersions: z.lazy(() => ModelVersions$inboundSchema),
+  osNgdData: z.lazy(() => OsNgdData$inboundSchema).optional(),
+  processingTimeMs: z.number(),
+  timestamp: z.string(),
+  verificationId: z.string().optional(),
+});
+
+export function metadataFromJSON(
+  jsonString: string,
+): SafeParseResult<Metadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Metadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Metadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const OwnershipType$inboundSchema: z.ZodNativeEnum<
+  typeof OwnershipType
+> = z.nativeEnum(OwnershipType);
+
+/** @internal */
+export const PropertyData$inboundSchema: z.ZodType<
+  PropertyData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bathrooms: z.nullable(z.number()).optional(),
+  bedrooms: z.nullable(z.number()).optional(),
+  buildDate: z.nullable(z.string()).optional(),
+  councilTaxBand: z.nullable(z.string()).optional(),
+  currentOwner: z.nullable(z.string()).optional(),
+  epcRating: z.nullable(z.string()).optional(),
+  floorArea: z.nullable(z.number()).optional(),
+  ownershipType: z.nullable(OwnershipType$inboundSchema).optional(),
+  propertyType: z.nullable(z.string()).optional(),
+  tenure: z.nullable(z.string()).optional(),
+  uprn: z.string(),
+});
+
+export function propertyDataFromJSON(
+  jsonString: string,
+): SafeParseResult<PropertyData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PropertyData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PropertyData' from JSON`,
+  );
+}
+
+/** @internal */
+export const Likelihood$inboundSchema: z.ZodNativeEnum<typeof Likelihood> = z
+  .nativeEnum(Likelihood);
+
+/** @internal */
+export const Signals$inboundSchema: z.ZodType<Signals, z.ZodTypeDef, unknown> =
+  z.object({
+    confidence: z.number().optional(),
+    details: z.string(),
+    found: z.boolean(),
+    name: z.string(),
+  });
+
+export function signalsFromJSON(
+  jsonString: string,
+): SafeParseResult<Signals, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Signals$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Signals' from JSON`,
+  );
+}
+
+/** @internal */
+export const RightToUse$inboundSchema: z.ZodType<
+  RightToUse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  confidence: z.number(),
+  likelihood: Likelihood$inboundSchema,
+  reasoning: z.array(z.string()),
+  signals: z.array(z.lazy(() => Signals$inboundSchema)),
+  summary: z.string(),
+});
+
+export function rightToUseFromJSON(
+  jsonString: string,
+): SafeParseResult<RightToUse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RightToUse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RightToUse' from JSON`,
+  );
+}
+
+/** @internal */
+export const Decision$inboundSchema: z.ZodNativeEnum<typeof Decision> = z
+  .nativeEnum(Decision);
+
+/** @internal */
+export const RoaVerifyResponseRecommendedAction$inboundSchema: z.ZodNativeEnum<
+  typeof RoaVerifyResponseRecommendedAction
+> = z.nativeEnum(RoaVerifyResponseRecommendedAction);
+
+/** @internal */
+export const Verdict$inboundSchema: z.ZodType<Verdict, z.ZodTypeDef, unknown> =
+  z.object({
+    confidence: z.number(),
+    criticalIssues: z.array(z.string()).optional(),
+    decision: Decision$inboundSchema,
+    flags: z.array(z.string()),
+    recommendedAction: RoaVerifyResponseRecommendedAction$inboundSchema,
+    summary: z.string(),
+  });
+
+export function verdictFromJSON(
+  jsonString: string,
+): SafeParseResult<Verdict, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Verdict$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Verdict' from JSON`,
+  );
+}
+
+/** @internal */
+export const RoaVerifyResponse$inboundSchema: z.ZodType<
+  RoaVerifyResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  addressResolution: z.lazy(() => AddressResolution$inboundSchema),
+  appropriateness: z.lazy(() => Appropriateness$inboundSchema),
+  fraudRisk: z.lazy(() => FraudRisk$inboundSchema),
+  landRegistryVerification: z.lazy(() =>
+    LandRegistryVerification$inboundSchema
+  ),
+  metadata: z.lazy(() => Metadata$inboundSchema),
+  propertyData: z.lazy(() => PropertyData$inboundSchema).optional(),
+  rightToUse: z.lazy(() => RightToUse$inboundSchema),
+  verdict: z.lazy(() => Verdict$inboundSchema),
+});
+
+export function roaVerifyResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<RoaVerifyResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RoaVerifyResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RoaVerifyResponse' from JSON`,
+  );
+}