@iflow-mcp/kitfunso-luminus 0.2.0

package/dist/tools/grid-connection-intelligence.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { type GisSourceMetadata } from "../lib/gis-sources.js";
+export declare const gridConnectionIntelligenceSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    radius_km: z.ZodOptional<z.ZodNumber>;
+    country: z.ZodString;
+}, z.core.$strip>;
+interface NearestGspResult {
+    gsp_id: string;
+    gsp_name: string;
+    distance_km: number;
+    region_id: string;
+    region_name: string;
+}
+interface ConnectionQueueResult {
+    projects: Array<Record<string, unknown>>;
+    total_mw_queued: number;
+    search_term: string;
+}
+interface NearbySubstation {
+    name: string | null;
+    voltage_kv: number | null;
+    distance_km: number;
+}
+interface GridConnectionIntelligenceResult {
+    lat: number;
+    lon: number;
+    country: string;
+    nearest_gsp: NearestGspResult | null;
+    connection_queue: ConnectionQueueResult | null;
+    nearby_substations: NearbySubstation[];
+    confidence_notes: string[];
+    source_metadata: {
+        gsp_lookup: GisSourceMetadata;
+        tec_register: GisSourceMetadata;
+        grid_proximity: GisSourceMetadata;
+    };
+    disclaimer: string;
+}
+export declare function getGridConnectionIntelligence(params: z.infer<typeof gridConnectionIntelligenceSchema>): Promise<GridConnectionIntelligenceResult>;
+export {};

package/dist/tools/grid-connection-intelligence.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { lookupGspRegion } from "../lib/neso-gsp.js";
+import { getGridConnectionQueue } from "./grid-connection-queue.js";
+import { getGridProximity } from "./grid-proximity.js";
+import { GIS_SOURCES } from "../lib/gis-sources.js";
+export const gridConnectionIntelligenceSchema = z.object({
+    lat: z.number().describe("Latitude (-90 to 90). WGS84."),
+    lon: z.number().describe("Longitude (-180 to 180). WGS84."),
+    radius_km: z
+        .number()
+        .optional()
+        .describe("GSP search radius in km (default 25, max 50)."),
+    country: z.string().describe('Only "GB" is supported.'),
+});
+const DISCLAIMER = "This combines a nearest-GSP spatial approximation with the NESO TEC register and OSM substation data. " +
+    "It is not a connection offer, capacity guarantee, or DNO headroom assessment. " +
+    "Always verify with the relevant network operator before making connection decisions.";
+function buildConfidenceNotes(gspResult) {
+    const notes = [
+        "GSP lookup uses nearest-GSP approximation, not polygon containment",
+        "TEC register connection sites are matched by GSP name substring, not spatial coordinates",
+        "Connection queue data shows contracted positions, not guaranteed available capacity",
+    ];
+    if (!gspResult) {
+        notes.push("No GSP found within search radius");
+    }
+    return notes;
+}
+function deriveSearchTerm(regionName) {
+    // Region names are already human-readable (e.g. "Berkswell", "Bramley")
+    return regionName.trim();
+}
+export async function getGridConnectionIntelligence(params) {
+    const { lat, lon, country } = params;
+    const radiusKm = params.radius_km ?? 25;
+    if (country.toUpperCase() !== "GB") {
+        throw new Error('Only country "GB" is supported for grid connection intelligence.');
+    }
+    if (lat < -90 || lat > 90)
+        throw new Error("Latitude must be between -90 and 90.");
+    if (lon < -180 || lon > 180)
+        throw new Error("Longitude must be between -180 and 180.");
+    if (radiusKm <= 0 || radiusKm > 50)
+        throw new Error("radius_km must be between 0 and 50.");
+    // Step 1: Find nearest GSP
+    const gspResult = await lookupGspRegion(lat, lon, radiusKm);
+    // Step 2: In parallel, query TEC register (if GSP found) and nearby substations
+    // Use region_name (e.g. "Berkswell") not gsp_name (e.g. "BESW_1") — TEC register
+    // Connection Site values are human-readable names like "Berkswell GSP"
+    const tecPromise = gspResult
+        ? queryTecRegister(gspResult.region_name)
+        : Promise.resolve(null);
+    const proximityPromise = queryGridProximity(lat, lon, radiusKm);
+    const [connectionQueue, nearbySubstations] = await Promise.all([
+        tecPromise,
+        proximityPromise,
+    ]);
+    return {
+        lat,
+        lon,
+        country: "GB",
+        nearest_gsp: gspResult
+            ? {
+                gsp_id: gspResult.gsp_id,
+                gsp_name: gspResult.gsp_name,
+                distance_km: gspResult.distance_km,
+                region_id: gspResult.region_id,
+                region_name: gspResult.region_name,
+            }
+            : null,
+        connection_queue: connectionQueue,
+        nearby_substations: nearbySubstations,
+        confidence_notes: buildConfidenceNotes(gspResult),
+        source_metadata: {
+            gsp_lookup: GIS_SOURCES["neso-gsp-lookup"],
+            tec_register: GIS_SOURCES["neso-tec-register"],
+            grid_proximity: GIS_SOURCES["overpass-osm"],
+        },
+        disclaimer: DISCLAIMER,
+    };
+}
+async function queryTecRegister(regionName) {
+    const searchTerm = deriveSearchTerm(regionName);
+    if (searchTerm.length === 0)
+        return null;
+    try {
+        const result = await getGridConnectionQueue({
+            connection_site_query: searchTerm,
+            limit: 50,
+        });
+        const totalMwQueued = result.summary.total_net_change_mw;
+        return {
+            projects: result.projects,
+            total_mw_queued: totalMwQueued,
+            search_term: searchTerm,
+        };
+    }
+    catch {
+        // TEC register failure should not block the overall result
+        return null;
+    }
+}
+async function queryGridProximity(lat, lon, radiusKm) {
+    try {
+        // grid-proximity has a max radius of 25km
+        const clampedRadius = Math.min(radiusKm, 25);
+        const result = await getGridProximity({
+            lat,
+            lon,
+            radius_km: clampedRadius,
+        });
+        return result.substations.map((sub) => ({
+            name: sub.name,
+            voltage_kv: sub.voltage_kv,
+            distance_km: sub.distance_km,
+        }));
+    }
+    catch {
+        // Proximity failure should not block the overall result
+        return [];
+    }
+}

package/dist/tools/grid-connection-queue.d.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { type GisSourceMetadata } from "../lib/gis-sources.js";
+export declare const gridConnectionQueueSchema: z.ZodObject<{
+    connection_site_query: z.ZodOptional<z.ZodString>;
+    project_name_query: z.ZodOptional<z.ZodString>;
+    host_to: z.ZodOptional<z.ZodString>;
+    plant_type: z.ZodOptional<z.ZodString>;
+    project_status: z.ZodOptional<z.ZodString>;
+    agreement_type: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface ProjectMatch {
+    project_name: string;
+    customer_name: string | null;
+    connection_site: string;
+    stage: number | null;
+    mw_connected: number;
+    mw_increase_decrease: number;
+    cumulative_total_capacity_mw: number;
+    mw_effective_from: string | null;
+    project_status: string | null;
+    agreement_type: string | null;
+    host_to: string | null;
+    plant_type: string | null;
+    project_id: string | null;
+    project_number: string | null;
+    gate: number | null;
+}
+interface ConnectionSiteSummary {
+    connection_site: string;
+    project_count: number;
+    total_net_change_mw: number;
+    total_connected_mw: number;
+    total_cumulative_capacity_mw: number;
+    plant_types: string[];
+    project_statuses: string[];
+    earliest_effective_from: string | null;
+}
+interface GridConnectionQueueResult {
+    filters: {
+        connection_site_query: string | null;
+        project_name_query: string | null;
+        host_to: string | null;
+        plant_type: string | null;
+        project_status: string | null;
+        agreement_type: string | null;
+    };
+    summary: {
+        matched_projects: number;
+        returned_projects: number;
+        total_connected_mw: number;
+        total_net_change_mw: number;
+        total_cumulative_capacity_mw: number;
+        earliest_effective_from: string | null;
+        latest_effective_from: string | null;
+    };
+    connection_sites: ConnectionSiteSummary[];
+    projects: ProjectMatch[];
+    source_metadata: GisSourceMetadata;
+    disclaimer: string;
+}
+export declare function resetGridConnectionQueueCacheForTests(): void;
+export declare function getGridConnectionQueue(params: z.infer<typeof gridConnectionQueueSchema>): Promise<GridConnectionQueueResult>;
+export {};

package/dist/tools/grid-connection-queue.js

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+import { GIS_SOURCES } from "../lib/gis-sources.js";
+import { guardJsonFields } from "../lib/schema-guard.js";
+const cache = new TtlCache();
+const NESO_TEC_RESOURCE_ID = "17becbab-e3e8-473f-b303-3806f43a6a10";
+const NESO_TEC_DATASTORE_URL = `https://api.neso.energy/api/3/action/datastore_search?resource_id=${NESO_TEC_RESOURCE_ID}&limit=5000`;
+export const gridConnectionQueueSchema = z.object({
+    connection_site_query: z
+        .string()
+        .optional()
+        .describe("Case-insensitive substring match on NESO Connection Site, for example \"Berkswell\"."),
+    project_name_query: z
+        .string()
+        .optional()
+        .describe("Case-insensitive substring match on Project Name."),
+    host_to: z
+        .string()
+        .optional()
+        .describe('Filter by host transmission owner, for example "NGET", "SPT", or "SHET".'),
+    plant_type: z
+        .string()
+        .optional()
+        .describe('Case-insensitive exact match on Plant Type, for example "Solar" or "Energy Storage System".'),
+    project_status: z
+        .string()
+        .optional()
+        .describe('Case-insensitive exact match on Project Status, for example "Scoping" or "Awaiting Consents".'),
+    agreement_type: z
+        .string()
+        .optional()
+        .describe('Case-insensitive exact match on Agreement Type, for example "Embedded" or "Directly Connected".'),
+    limit: z
+        .number()
+        .optional()
+        .describe("Maximum number of matched projects to return (default 20, max 50)."),
+});
+const DISCLAIMER = "This uses the public NESO Transmission Entry Capacity register as a GB transmission-level connection signal. " +
+    "It is not a DNO headroom map, queue-position guarantee, or connection offer. " +
+    "Connection site names reflect NESO register naming and may not match local substation labels exactly.";
+export function resetGridConnectionQueueCacheForTests() {
+    cache.clear();
+}
+function normaliseText(value) {
+    return (value ?? "").trim().toLowerCase();
+}
+function round1(value) {
+    return Math.round(value * 10) / 10;
+}
+function toProject(record) {
+    return {
+        project_name: record["Project Name"] ?? "Unknown project",
+        customer_name: record["Customer Name"] ?? null,
+        connection_site: record["Connection Site"] ?? "Unknown connection site",
+        stage: typeof record.Stage === "number" ? record.Stage : null,
+        mw_connected: typeof record["MW Connected"] === "number" ? record["MW Connected"] : 0,
+        mw_increase_decrease: typeof record["MW Increase / Decrease"] === "number" ? record["MW Increase / Decrease"] : 0,
+        cumulative_total_capacity_mw: typeof record["Cumulative Total Capacity (MW)"] === "number"
+            ? record["Cumulative Total Capacity (MW)"]
+            : 0,
+        mw_effective_from: record["MW Effective From"] ?? null,
+        project_status: record["Project Status"] ?? null,
+        agreement_type: record["Agreement Type"] ?? null,
+        host_to: record["HOST TO"] ?? null,
+        plant_type: record["Plant Type"] ?? null,
+        project_id: record["Project ID"] ?? null,
+        project_number: record["Project Number"] ?? null,
+        gate: typeof record.Gate === "number" ? record.Gate : null,
+    };
+}
+async function fetchNesoTecRegister() {
+    const cached = cache.get("neso-tec-register:all");
+    if (cached)
+        return cached;
+    const response = await fetch(NESO_TEC_DATASTORE_URL);
+    if (!response.ok) {
+        throw new Error(`NESO API returned ${response.status}`);
+    }
+    const json = await response.json();
+    if (!json.success) {
+        throw new Error(json.error?.message ?? "NESO datastore request failed");
+    }
+    const records = Array.isArray(json.result?.records) ? json.result.records : [];
+    if (records.length > 0) {
+        guardJsonFields(records[0], [
+            "Project Name",
+            "Connection Site",
+            "MW Connected",
+            "MW Increase / Decrease",
+            "Cumulative Total Capacity (MW)",
+            "Project Status",
+            "HOST TO",
+            "Plant Type",
+        ], "NESO TEC Register");
+    }
+    const projects = records.map(toProject);
+    cache.set("neso-tec-register:all", projects, TTL.STATIC_DATA);
+    return projects;
+}
+function matchesExactFilter(value, filter) {
+    if (!filter)
+        return true;
+    return normaliseText(value ?? undefined) === normaliseText(filter);
+}
+function matchesSubstring(value, query) {
+    if (!query)
+        return true;
+    return normaliseText(value ?? undefined).includes(normaliseText(query));
+}
+function summariseConnectionSites(projects) {
+    const grouped = new Map();
+    for (const project of projects) {
+        const existing = grouped.get(project.connection_site) ?? [];
+        existing.push(project);
+        grouped.set(project.connection_site, existing);
+    }
+    return [...grouped.entries()]
+        .map(([connectionSite, siteProjects]) => {
+        const dates = siteProjects
+            .map((p) => p.mw_effective_from)
+            .filter((d) => typeof d === "string" && d.length > 0)
+            .sort();
+        return {
+            connection_site: connectionSite,
+            project_count: siteProjects.length,
+            total_net_change_mw: round1(siteProjects.reduce((sum, p) => sum + p.mw_increase_decrease, 0)),
+            total_connected_mw: round1(siteProjects.reduce((sum, p) => sum + p.mw_connected, 0)),
+            total_cumulative_capacity_mw: round1(siteProjects.reduce((sum, p) => sum + p.cumulative_total_capacity_mw, 0)),
+            plant_types: [...new Set(siteProjects.map((p) => p.plant_type).filter((v) => Boolean(v)))].sort(),
+            project_statuses: [...new Set(siteProjects.map((p) => p.project_status).filter((v) => Boolean(v)))].sort(),
+            earliest_effective_from: dates[0] ?? null,
+        };
+    })
+        .sort((a, b) => b.total_net_change_mw - a.total_net_change_mw);
+}
+export async function getGridConnectionQueue(params) {
+    const limit = params.limit ?? 20;
+    if (limit <= 0 || limit > 50) {
+        throw new Error("limit must be between 1 and 50.");
+    }
+    if (!params.connection_site_query &&
+        !params.project_name_query &&
+        !params.host_to &&
+        !params.plant_type &&
+        !params.project_status &&
+        !params.agreement_type) {
+        throw new Error("At least one filter is required: connection_site_query, project_name_query, host_to, plant_type, project_status, or agreement_type.");
+    }
+    let projects;
+    try {
+        projects = await fetchNesoTecRegister();
+    }
+    catch (error) {
+        throw new Error(`NESO TEC register query failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const matched = projects.filter((project) => {
+        return (matchesSubstring(project.connection_site, params.connection_site_query) &&
+            matchesSubstring(project.project_name, params.project_name_query) &&
+            matchesExactFilter(project.host_to, params.host_to) &&
+            matchesExactFilter(project.plant_type, params.plant_type) &&
+            matchesExactFilter(project.project_status, params.project_status) &&
+            matchesExactFilter(project.agreement_type, params.agreement_type));
+    });
+    matched.sort((a, b) => {
+        const dateA = a.mw_effective_from ?? "9999-12-31";
+        const dateB = b.mw_effective_from ?? "9999-12-31";
+        if (dateA !== dateB)
+            return dateA.localeCompare(dateB);
+        return b.mw_increase_decrease - a.mw_increase_decrease;
+    });
+    const dates = matched
+        .map((p) => p.mw_effective_from)
+        .filter((d) => typeof d === "string" && d.length > 0)
+        .sort();
+    return {
+        filters: {
+            connection_site_query: params.connection_site_query ?? null,
+            project_name_query: params.project_name_query ?? null,
+            host_to: params.host_to ?? null,
+            plant_type: params.plant_type ?? null,
+            project_status: params.project_status ?? null,
+            agreement_type: params.agreement_type ?? null,
+        },
+        summary: {
+            matched_projects: matched.length,
+            returned_projects: Math.min(matched.length, limit),
+            total_connected_mw: round1(matched.reduce((sum, p) => sum + p.mw_connected, 0)),
+            total_net_change_mw: round1(matched.reduce((sum, p) => sum + p.mw_increase_decrease, 0)),
+            total_cumulative_capacity_mw: round1(matched.reduce((sum, p) => sum + p.cumulative_total_capacity_mw, 0)),
+            earliest_effective_from: dates[0] ?? null,
+            latest_effective_from: dates[dates.length - 1] ?? null,
+        },
+        connection_sites: summariseConnectionSites(matched),
+        projects: matched.slice(0, limit),
+        source_metadata: GIS_SOURCES["neso-tec-register"],
+        disclaimer: DISCLAIMER,
+    };
+}

package/dist/tools/grid-proximity.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { type GisSourceMetadata } from "../lib/gis-sources.js";
+export declare const gridProximitySchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+    radius_km: z.ZodOptional<z.ZodNumber>;
+    voltage_min_kv: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface Substation {
+    name: string | null;
+    voltage_kv: number | null;
+    operator: string | null;
+    distance_km: number;
+    lat: number;
+    lon: number;
+}
+interface Line {
+    voltage_kv: number;
+    operator: string | null;
+    distance_km: number;
+    cables: number | null;
+}
+interface GridProximitySummary {
+    nearest_substation_km: number | null;
+    nearest_line_km: number | null;
+    max_nearby_voltage_kv: number | null;
+}
+interface GridProximityResult {
+    lat: number;
+    lon: number;
+    radius_km: number;
+    substations: Substation[];
+    lines: Line[];
+    summary: GridProximitySummary;
+    source_metadata: GisSourceMetadata;
+}
+export declare function getGridProximity(params: z.infer<typeof gridProximitySchema>): Promise<GridProximityResult>;
+export {};

package/dist/tools/grid-proximity.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+import { fetchOverpassJson } from "../lib/overpass.js";
+import { GIS_SOURCES } from "../lib/gis-sources.js";
+const cache = new TtlCache();
+export const gridProximitySchema = z.object({
+    lat: z
+        .number()
+        .describe("Latitude (-90 to 90). WGS84."),
+    lon: z
+        .number()
+        .describe("Longitude (-180 to 180). WGS84."),
+    radius_km: z
+        .number()
+        .optional()
+        .describe("Search radius in km (default 5, max 25)."),
+    voltage_min_kv: z
+        .number()
+        .optional()
+        .describe("Minimum voltage in kV to include (default 33)."),
+});
+function haversineKm(lat1, lon1, lat2, lon2) {
+    const R = 6371;
+    const dLat = (lat2 - lat1) * (Math.PI / 180);
+    const dLon = (lon2 - lon1) * (Math.PI / 180);
+    const a = Math.sin(dLat / 2) ** 2 +
+        Math.cos(lat1 * (Math.PI / 180)) *
+            Math.cos(lat2 * (Math.PI / 180)) *
+            Math.sin(dLon / 2) ** 2;
+    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+function parseVoltageKv(voltageStr) {
+    if (!voltageStr)
+        return null;
+    const v = Number(voltageStr.split(";")[0]);
+    if (Number.isNaN(v) || v <= 0)
+        return null;
+    return Math.round(v / 1000);
+}
+function minDistanceToWay(lat, lon, geometry) {
+    if (geometry.length === 0)
+        return Infinity;
+    let minDist = Infinity;
+    for (const pt of geometry) {
+        const d = haversineKm(lat, lon, pt.lat, pt.lon);
+        if (d < minDist)
+            minDist = d;
+    }
+    return minDist;
+}
+export async function getGridProximity(params) {
+    const { lat, lon } = params;
+    const radiusKm = params.radius_km ?? 5;
+    const voltageMinKv = params.voltage_min_kv ?? 33;
+    if (lat < -90 || lat > 90)
+        throw new Error("Latitude must be between -90 and 90.");
+    if (lon < -180 || lon > 180)
+        throw new Error("Longitude must be between -180 and 180.");
+    if (radiusKm <= 0 || radiusKm > 25)
+        throw new Error("radius_km must be between 0 and 25.");
+    const cacheKey = `grid-prox:${lat}:${lon}:${radiusKm}:${voltageMinKv}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const radiusM = radiusKm * 1000;
+    const query = `[out:json][timeout:30];(
+    node["power"="substation"](around:${radiusM},${lat},${lon});
+    way["power"="line"](around:${radiusM},${lat},${lon});
+  );out geom;`;
+    const json = await fetchOverpassJson(query);
+    const elements = Array.isArray(json.elements) ? json.elements : [];
+    const substations = [];
+    const lines = [];
+    for (const el of elements) {
+        if (el.tags?.power === "substation" && el.type === "node") {
+            const vKv = parseVoltageKv(el.tags?.voltage);
+            substations.push({
+                name: el.tags?.name ?? null,
+                voltage_kv: vKv,
+                operator: el.tags?.operator ?? null,
+                distance_km: Math.round(haversineKm(lat, lon, el.lat, el.lon) * 100) / 100,
+                lat: el.lat,
+                lon: el.lon,
+            });
+        }
+        if (el.tags?.power === "line" && el.type === "way") {
+            const vKv = parseVoltageKv(el.tags?.voltage);
+            if (vKv !== null && vKv < voltageMinKv)
+                continue;
+            const geometry = Array.isArray(el.geometry)
+                ? el.geometry.map((g) => ({ lat: g.lat, lon: g.lon }))
+                : [];
+            lines.push({
+                voltage_kv: vKv ?? 0,
+                operator: el.tags?.operator ?? null,
+                distance_km: Math.round(minDistanceToWay(lat, lon, geometry) * 100) / 100,
+                cables: el.tags?.cables ? Number(el.tags.cables) : null,
+            });
+        }
+    }
+    substations.sort((a, b) => a.distance_km - b.distance_km);
+    lines.sort((a, b) => a.distance_km - b.distance_km);
+    const allVoltages = [
+        ...substations.map((s) => s.voltage_kv).filter((v) => v !== null),
+        ...lines.map((l) => l.voltage_kv),
+    ];
+    const summary = {
+        nearest_substation_km: substations.length > 0 ? substations[0].distance_km : null,
+        nearest_line_km: lines.length > 0 ? lines[0].distance_km : null,
+        max_nearby_voltage_kv: allVoltages.length > 0 ? Math.max(...allVoltages) : null,
+    };
+    const result = {
+        lat,
+        lon,
+        radius_km: radiusKm,
+        substations,
+        lines,
+        summary,
+        source_metadata: GIS_SOURCES["overpass-osm"],
+    };
+    cache.set(cacheKey, result, TTL.STATIC_DATA);
+    return result;
+}

package/dist/tools/hydro-inflows.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const hydroInflowsSchema: z.ZodObject<{
+    country: z.ZodString;
+    period: z.ZodOptional<z.ZodEnum<{
+        recent: "recent";
+        historical: "historical";
+    }>>;
+}, z.core.$strip>;
+interface DailyInflow {
+    date: string;
+    precipitation_mm: number;
+    snowfall_mm: number;
+    temperature_max_c: number;
+    rain_mm: number;
+    inflow_proxy_index: number;
+}
+interface HydroInflowResult {
+    source: string;
+    country: string;
+    basin_description: string;
+    latitude: number;
+    longitude: number;
+    period_days: number;
+    daily: DailyInflow[];
+    summary: {
+        total_precipitation_mm: number;
+        total_snowfall_mm: number;
+        avg_temperature_c: number;
+        avg_inflow_proxy: number;
+        trend: string;
+    };
+}
+export declare function getHydroInflows(params: z.infer<typeof hydroInflowsSchema>): Promise<HydroInflowResult>;
+export {};