@vepler/sdk 2.39.0 → 2.45.0

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

@@ -46,6 +46,31 @@ export type ConstructionAge = {
   yearTo?: number | undefined;
 };
 
+/**
+ * GeoJSON geometry type
+ */
+export const GetEpcByLocationIdType = {
+  Point: "Point",
+} as const;
+/**
+ * GeoJSON geometry type
+ */
+export type GetEpcByLocationIdType = ClosedEnum<typeof GetEpcByLocationIdType>;
+
+/**
+ * GeoJSON Point geometry with coordinates in [longitude, latitude] order (WGS84). Null if the property could not be geocoded.
+ */
+export type GetEpcByLocationIdGeoJSONPoint = {
+  /**
+   * Coordinate pair [longitude, latitude]
+   */
+  coordinates: Array<number>;
+  /**
+   * GeoJSON geometry type
+   */
+  type: GetEpcByLocationIdType;
+};
+
 /**
  * Geographic location attributes for the property
  */
@@ -121,7 +146,7 @@ export type Data = {
   /**
    * GeoJSON Point geometry with coordinates in [longitude, latitude] order (WGS84). Null if the property could not be geocoded.
    */
-  coordinates?: any | null | undefined;
+  coordinates: GetEpcByLocationIdGeoJSONPoint | null;
   /**
    * County name where applicable
    */
@@ -518,6 +543,31 @@ export function constructionAgeFromJSON(
   );
 }
 
+/** @internal */
+export const GetEpcByLocationIdType$inboundSchema: z.ZodNativeEnum<
+  typeof GetEpcByLocationIdType
+> = z.nativeEnum(GetEpcByLocationIdType);
+
+/** @internal */
+export const GetEpcByLocationIdGeoJSONPoint$inboundSchema: z.ZodType<
+  GetEpcByLocationIdGeoJSONPoint,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  coordinates: z.array(z.number()),
+  type: GetEpcByLocationIdType$inboundSchema,
+});
+
+export function getEpcByLocationIdGeoJSONPointFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEpcByLocationIdGeoJSONPoint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEpcByLocationIdGeoJSONPoint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEpcByLocationIdGeoJSONPoint' from JSON`,
+  );
+}
+
 /** @internal */
 export const Location$inboundSchema: z.ZodType<
   Location,
@@ -572,7 +622,9 @@ export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
     constituencyLabel: z.nullable(z.string()),
     constructionAge: z.nullable(z.lazy(() => ConstructionAge$inboundSchema))
       .optional(),
-    coordinates: z.nullable(z.any()).optional(),
+    coordinates: z.nullable(
+      z.lazy(() => GetEpcByLocationIdGeoJSONPoint$inboundSchema),
+    ),
     county: z.nullable(z.string()),
     createdAt: z.string(),
     currentEnergyEfficiency: z.nullable(z.number()),

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

@@ -137,7 +137,7 @@ export type Series = {
 /**
  * School metrics time series response
  */
-export type Two = {
+export type GetSchoolMetrics2 = {
   definitions?: Array<GetSchoolMetricsDefinitions> | undefined;
   metricCodes: Array<string>;
   schoolId: number;
@@ -205,14 +205,16 @@ export type Metrics = {
 /**
  * School metrics response for point-in-time data
  */
-export type One = {
+export type GetSchoolMetrics1 = {
   comparisons?: { [k: string]: Comparisons } | undefined;
   definitions?: Array<Definitions> | undefined;
   metrics: Array<Metrics>;
   schoolId: number;
 };
 
-export type GetSchoolMetricsData = Array<One> | Array<Two>;
+export type GetSchoolMetricsData =
+  | Array<GetSchoolMetrics1>
+  | Array<GetSchoolMetrics2>;
 
 export const GetSchoolMetricsObject = {
   List: "list",
@@ -223,7 +225,7 @@ export type GetSchoolMetricsObject = ClosedEnum<typeof GetSchoolMetricsObject>;
  * Paginated metrics response envelope
  */
 export type GetSchoolMetricsResponseBody = {
-  data: Array<One> | Array<Two>;
+  data: Array<GetSchoolMetrics1> | Array<GetSchoolMetrics2>;
   hasMore: boolean;
   object: GetSchoolMetricsObject;
   totalCount?: number | undefined;
@@ -355,23 +357,25 @@ export function seriesFromJSON(
 }
 
 /** @internal */
-export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z
-  .object({
-    definitions: z.array(
-      z.lazy(() => GetSchoolMetricsDefinitions$inboundSchema),
-    ).optional(),
-    metricCodes: z.array(z.string()),
-    schoolId: z.number(),
-    series: z.array(z.lazy(() => Series$inboundSchema)),
-  });
+export const GetSchoolMetrics2$inboundSchema: z.ZodType<
+  GetSchoolMetrics2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  definitions: z.array(z.lazy(() => GetSchoolMetricsDefinitions$inboundSchema))
+    .optional(),
+  metricCodes: z.array(z.string()),
+  schoolId: z.number(),
+  series: z.array(z.lazy(() => Series$inboundSchema)),
+});
 
-export function twoFromJSON(
+export function getSchoolMetrics2FromJSON(
   jsonString: string,
-): SafeParseResult<Two, SDKValidationError> {
+): SafeParseResult<GetSchoolMetrics2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Two$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Two' from JSON`,
+    (x) => GetSchoolMetrics2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSchoolMetrics2' from JSON`,
   );
 }
 
@@ -486,21 +490,24 @@ export function metricsFromJSON(
 }
 
 /** @internal */
-export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
-  .object({
-    comparisons: z.record(z.lazy(() => Comparisons$inboundSchema)).optional(),
-    definitions: z.array(z.lazy(() => Definitions$inboundSchema)).optional(),
-    metrics: z.array(z.lazy(() => Metrics$inboundSchema)),
-    schoolId: z.number(),
-  });
+export const GetSchoolMetrics1$inboundSchema: z.ZodType<
+  GetSchoolMetrics1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  comparisons: z.record(z.lazy(() => Comparisons$inboundSchema)).optional(),
+  definitions: z.array(z.lazy(() => Definitions$inboundSchema)).optional(),
+  metrics: z.array(z.lazy(() => Metrics$inboundSchema)),
+  schoolId: z.number(),
+});
 
-export function oneFromJSON(
+export function getSchoolMetrics1FromJSON(
   jsonString: string,
-): SafeParseResult<One, SDKValidationError> {
+): SafeParseResult<GetSchoolMetrics1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => One$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'One' from JSON`,
+    (x) => GetSchoolMetrics1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSchoolMetrics1' from JSON`,
   );
 }
 
@@ -510,8 +517,8 @@ export const GetSchoolMetricsData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.array(z.lazy(() => One$inboundSchema)),
-  z.array(z.lazy(() => Two$inboundSchema)),
+  z.array(z.lazy(() => GetSchoolMetrics1$inboundSchema)),
+  z.array(z.lazy(() => GetSchoolMetrics2$inboundSchema)),
 ]);
 
 export function getSchoolMetricsDataFromJSON(
@@ -536,8 +543,8 @@ export const GetSchoolMetricsResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   data: z.union([
-    z.array(z.lazy(() => One$inboundSchema)),
-    z.array(z.lazy(() => Two$inboundSchema)),
+    z.array(z.lazy(() => GetSchoolMetrics1$inboundSchema)),
+    z.array(z.lazy(() => GetSchoolMetrics2$inboundSchema)),
   ]),
   has_more: z.boolean(),
   object: GetSchoolMetricsObject$inboundSchema,

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

@@ -0,0 +1,193 @@
+/*
+ * 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 GetSubstationByCodeRequest = {
+  code: string;
+};
+
+/**
+ * WGS84 coordinate pair
+ */
+export type GetSubstationByCodeCoordinates = {
+  /**
+   * Latitude in decimal degrees
+   */
+  lat: number;
+  /**
+   * Longitude in decimal degrees
+   */
+  lng: number;
+};
+
+/**
+ * Object type identifier
+ */
+export const GetSubstationByCodeObject = {
+  Substation: "substation",
+} as const;
+/**
+ * Object type identifier
+ */
+export type GetSubstationByCodeObject = ClosedEnum<
+  typeof GetSubstationByCodeObject
+>;
+
+/**
+ * A network operator substation with its current capacity and headroom data
+ */
+export type GetSubstationByCodeSubstation = {
+  /**
+   * Unique substation identifier, prefixed with the operator code
+   */
+  code: string;
+  /**
+   * ISO 3166-1 alpha-2 country code
+   */
+  country: string;
+  /**
+   * Available spare capacity for new demand connections, in megawatts (MW). Calculated as firm capacity minus peak demand
+   */
+  demandHeadroomMw: number | null;
+  /**
+   * Current peak electricity demand at this substation, in megawatts (MW)
+   */
+  demandMw: number | null;
+  /**
+   * Maximum firm capacity rating, in megawatts (MW). This is the guaranteed capacity available under all operating conditions
+   */
+  firmCapacityMw: number | null;
+  /**
+   * Available spare capacity for new generation connections (e.g. solar, wind), in megawatts (MW)
+   */
+  generationHeadroomMw: number | null;
+  /**
+   * WGS84 coordinate pair
+   */
+  location: GetSubstationByCodeCoordinates | null;
+  /**
+   * Human-readable substation name, where available
+   */
+  name: string | null;
+  /**
+   * Object type identifier
+   */
+  object: GetSubstationByCodeObject;
+  /**
+   * Operating region name (e.g. 'UKPN (SPN)' in GB, or region name in other countries)
+   */
+  operatingRegion: string | null;
+  /**
+   * Network operator identifier. Known values include: 'ukpn', 'npg', 'nged', 'ssen', 'spen', 'enw', 'neso'. New operators can be added without code changes.
+   */
+  operator: string;
+  /**
+   * Code of the parent substation in the network hierarchy (e.g. a primary's parent grid substation). Null for top-level GSPs
+   */
+  parentSubstationCode: string | null;
+  /**
+   * Maximum capacity for reverse power flow (generation exceeding local demand), in megawatts (MW)
+   */
+  reversePowerCapacityMw: number | null;
+  /**
+   * Classification of substation within the electricity network hierarchy. Known values: 'gsp', 'bulk_supply', 'grid', 'primary', 'distribution'. 'gsp' (Grid Supply Point) connects to the national transmission grid. 'bulk_supply' and 'grid' operate at intermediate voltages. 'primary' steps down to 11kV for local distribution. 'distribution' serves end customers at low voltage.
+   */
+  substationType: string | null;
+  /**
+   * Current utilisation as a percentage of firm capacity. Higher values indicate less available headroom
+   */
+  utilisationPct: number | null;
+  /**
+   * Operating voltage, in kilovolts (kV)
+   */
+  voltageKv: number | null;
+};
+
+/** @internal */
+export type GetSubstationByCodeRequest$Outbound = {
+  code: string;
+};
+
+/** @internal */
+export const GetSubstationByCodeRequest$outboundSchema: z.ZodType<
+  GetSubstationByCodeRequest$Outbound,
+  z.ZodTypeDef,
+  GetSubstationByCodeRequest
+> = z.object({
+  code: z.string(),
+});
+
+export function getSubstationByCodeRequestToJSON(
+  getSubstationByCodeRequest: GetSubstationByCodeRequest,
+): string {
+  return JSON.stringify(
+    GetSubstationByCodeRequest$outboundSchema.parse(getSubstationByCodeRequest),
+  );
+}
+
+/** @internal */
+export const GetSubstationByCodeCoordinates$inboundSchema: z.ZodType<
+  GetSubstationByCodeCoordinates,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lat: z.number(),
+  lng: z.number(),
+});
+
+export function getSubstationByCodeCoordinatesFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSubstationByCodeCoordinates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSubstationByCodeCoordinates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSubstationByCodeCoordinates' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetSubstationByCodeObject$inboundSchema: z.ZodNativeEnum<
+  typeof GetSubstationByCodeObject
+> = z.nativeEnum(GetSubstationByCodeObject);
+
+/** @internal */
+export const GetSubstationByCodeSubstation$inboundSchema: z.ZodType<
+  GetSubstationByCodeSubstation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  code: z.string(),
+  country: z.string(),
+  demandHeadroomMw: z.nullable(z.number()),
+  demandMw: z.nullable(z.number()),
+  firmCapacityMw: z.nullable(z.number()),
+  generationHeadroomMw: z.nullable(z.number()),
+  location: z.nullable(
+    z.lazy(() => GetSubstationByCodeCoordinates$inboundSchema),
+  ),
+  name: z.nullable(z.string()),
+  object: GetSubstationByCodeObject$inboundSchema,
+  operatingRegion: z.nullable(z.string()),
+  operator: z.string(),
+  parentSubstationCode: z.nullable(z.string()),
+  reversePowerCapacityMw: z.nullable(z.number()),
+  substationType: z.nullable(z.string()),
+  utilisationPct: z.nullable(z.number()),
+  voltageKv: z.nullable(z.number()),
+});
+
+export function getSubstationByCodeSubstationFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSubstationByCodeSubstation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSubstationByCodeSubstation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSubstationByCodeSubstation' from JSON`,
+  );
+}

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

@@ -0,0 +1,227 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { safeParse } from "../../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type GetSubstationCapacityRequest = {
+  code: string;
+  /**
+   * Start date for the time range (inclusive, ISO 8601)
+   */
+  from?: string | undefined;
+  /**
+   * End date for the time range (inclusive, ISO 8601)
+   */
+  to?: string | undefined;
+};
+
+/**
+ * Object type identifier
+ */
+export const GetSubstationCapacityEnergyObject = {
+  CapacitySnapshot: "capacity_snapshot",
+} as const;
+/**
+ * Object type identifier
+ */
+export type GetSubstationCapacityEnergyObject = ClosedEnum<
+  typeof GetSubstationCapacityEnergyObject
+>;
+
+/**
+ * A quarterly snapshot of substation capacity and headroom. Use these to track how available capacity changes over time
+ */
+export type GetSubstationCapacityCapacitySnapshot = {
+  /**
+   * Battery-specific headroom, in megawatts (MW). Only available from some operators
+   */
+  batteryHeadroomMw: number | null;
+  /**
+   * Available demand headroom at this snapshot date, in megawatts (MW)
+   */
+  demandHeadroomMw: number | null;
+  /**
+   * Peak demand at this snapshot date, in megawatts (MW)
+   */
+  demandMw: number | null;
+  /**
+   * Electric vehicle charger-specific headroom, in megawatts (MW). Only available from some operators
+   */
+  evHeadroomMw: number | null;
+  /**
+   * Firm capacity rating at this snapshot date, in megawatts (MW)
+   */
+  firmCapacityMw: number | null;
+  /**
+   * Available generation headroom at this snapshot date, in megawatts (MW)
+   */
+  generationHeadroomMw: number | null;
+  /**
+   * Object type identifier
+   */
+  object: GetSubstationCapacityEnergyObject;
+  /**
+   * Date of this capacity snapshot, typically the start of a quarter (ISO 8601)
+   */
+  snapshotDate: string;
+  /**
+   * Identifier for the data source this snapshot was extracted from
+   */
+  snapshotSource: string;
+  /**
+   * Solar-specific headroom, in megawatts (MW). Only available from some operators
+   */
+  solarHeadroomMw: number | null;
+  /**
+   * Code of the substation this snapshot belongs to
+   */
+  substationCode: string;
+  /**
+   * Utilisation percentage at this snapshot date
+   */
+  utilisationPct: number | null;
+};
+
+/**
+ * Object type identifier
+ */
+export const GetSubstationCapacityObject = {
+  List: "list",
+} as const;
+/**
+ * Object type identifier
+ */
+export type GetSubstationCapacityObject = ClosedEnum<
+  typeof GetSubstationCapacityObject
+>;
+
+/**
+ * Paginated list response
+ */
+export type GetSubstationCapacityResponseBody = {
+  /**
+   * Array of items
+   */
+  data: Array<GetSubstationCapacityCapacitySnapshot>;
+  /**
+   * Whether more items exist
+   */
+  hasMore: boolean;
+  /**
+   * Object type identifier
+   */
+  object: GetSubstationCapacityObject;
+  /**
+   * Total number of items available
+   */
+  totalCount?: number | undefined;
+  /**
+   * URL of the request
+   */
+  url: string;
+};
+
+/** @internal */
+export type GetSubstationCapacityRequest$Outbound = {
+  code: string;
+  from?: string | undefined;
+  to?: string | undefined;
+};
+
+/** @internal */
+export const GetSubstationCapacityRequest$outboundSchema: z.ZodType<
+  GetSubstationCapacityRequest$Outbound,
+  z.ZodTypeDef,
+  GetSubstationCapacityRequest
+> = z.object({
+  code: z.string(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+});
+
+export function getSubstationCapacityRequestToJSON(
+  getSubstationCapacityRequest: GetSubstationCapacityRequest,
+): string {
+  return JSON.stringify(
+    GetSubstationCapacityRequest$outboundSchema.parse(
+      getSubstationCapacityRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const GetSubstationCapacityEnergyObject$inboundSchema: z.ZodNativeEnum<
+  typeof GetSubstationCapacityEnergyObject
+> = z.nativeEnum(GetSubstationCapacityEnergyObject);
+
+/** @internal */
+export const GetSubstationCapacityCapacitySnapshot$inboundSchema: z.ZodType<
+  GetSubstationCapacityCapacitySnapshot,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  batteryHeadroomMw: z.nullable(z.number()),
+  demandHeadroomMw: z.nullable(z.number()),
+  demandMw: z.nullable(z.number()),
+  evHeadroomMw: z.nullable(z.number()),
+  firmCapacityMw: z.nullable(z.number()),
+  generationHeadroomMw: z.nullable(z.number()),
+  object: GetSubstationCapacityEnergyObject$inboundSchema,
+  snapshotDate: z.string(),
+  snapshotSource: z.string(),
+  solarHeadroomMw: z.nullable(z.number()),
+  substationCode: z.string(),
+  utilisationPct: z.nullable(z.number()),
+});
+
+export function getSubstationCapacityCapacitySnapshotFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSubstationCapacityCapacitySnapshot, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetSubstationCapacityCapacitySnapshot$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSubstationCapacityCapacitySnapshot' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetSubstationCapacityObject$inboundSchema: z.ZodNativeEnum<
+  typeof GetSubstationCapacityObject
+> = z.nativeEnum(GetSubstationCapacityObject);
+
+/** @internal */
+export const GetSubstationCapacityResponseBody$inboundSchema: z.ZodType<
+  GetSubstationCapacityResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(
+    z.lazy(() => GetSubstationCapacityCapacitySnapshot$inboundSchema),
+  ),
+  has_more: z.boolean(),
+  object: GetSubstationCapacityObject$inboundSchema,
+  total_count: z.number().optional(),
+  url: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+    "total_count": "totalCount",
+  });
+});
+
+export function getSubstationCapacityResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSubstationCapacityResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetSubstationCapacityResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSubstationCapacityResponseBody' from JSON`,
+  );
+}