@iflow-mcp/kitfunso-luminus 0.2.0

package/dist/tools/terna.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+const API_BASE = "https://api.terna.it/transparency/v1.0";
+const TERNA_PUBLIC = "https://www.terna.it/en/electric-system";
+const cache = new TtlCache();
+export const ternaSchema = z.object({
+    dataset: z
+        .enum(["generation", "demand", "exchanges", "market_data"])
+        .describe('"generation" = Italian electricity generation by source (MW). ' +
+        '"demand" = Italian electricity demand (MW). ' +
+        '"exchanges" = cross-border exchange flows with neighbours. ' +
+        '"market_data" = Italian zonal electricity market data.'),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+    zone: z
+        .string()
+        .optional()
+        .describe("Italian market zone: NORD, CNOR, CSUD, SUD, SICI, SARD, or ITALY (national). " +
+        "Defaults to ITALY."),
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function fetchTerna(endpoint) {
+    const cached = cache.get(endpoint);
+    if (cached)
+        return cached;
+    const response = await fetch(endpoint, {
+        headers: {
+            Accept: "application/json",
+            "User-Agent": "luminus-mcp/0.2",
+        },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Terna API returned ${response.status}: ${body.slice(0, 300)}`);
+    }
+    const json = await response.json();
+    cache.set(endpoint, json, TTL.REALTIME);
+    return json;
+}
+export async function getTernaData(params) {
+    const date = params.date ?? new Date().toISOString().slice(0, 10);
+    const zone = params.zone?.toUpperCase() ?? "ITALY";
+    try {
+        // Try Terna developer API first
+        const url = `${API_BASE}/${params.dataset}?date=${date}&zone=${zone}`;
+        const data = await fetchTerna(url);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const items = Array.isArray(data) ? data : data?.data ?? data?.records ?? [];
+        switch (params.dataset) {
+            case "generation": {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const records = items.slice(0, 24).map((r) => {
+                    const thermal = Number(r.thermal ?? r.termoelettrico ?? 0);
+                    const hydro = Number(r.hydro ?? r.idroelettrico ?? 0);
+                    const wind = Number(r.wind ?? r.eolico ?? 0);
+                    const solar = Number(r.solar ?? r.fotovoltaico ?? 0);
+                    const geo = Number(r.geothermal ?? r.geotermico ?? 0);
+                    const bio = Number(r.biomass ?? r.bioenergie ?? 0);
+                    const total = thermal + hydro + wind + solar + geo + bio;
+                    const renewable = hydro + wind + solar + geo + bio;
+                    return {
+                        timestamp: r.timestamp ?? r.datetime ?? "",
+                        thermal_mw: Math.round(thermal),
+                        hydro_mw: Math.round(hydro),
+                        wind_mw: Math.round(wind),
+                        solar_mw: Math.round(solar),
+                        geothermal_mw: Math.round(geo),
+                        biomass_mw: Math.round(bio),
+                        total_mw: Math.round(total),
+                        renewable_pct: total > 0 ? Math.round((renewable / total) * 1000) / 10 : 0,
+                    };
+                });
+                return {
+                    dataset: "generation",
+                    source: "Terna Transparency (developer.terna.it)",
+                    date,
+                    zone,
+                    records,
+                    latest: records.length > 0 ? records[0] : null,
+                };
+            }
+            case "demand": {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const records = items.slice(0, 24).map((r) => ({
+                    timestamp: r.timestamp ?? r.datetime ?? "",
+                    demand_mw: Math.round(Number(r.demand ?? r.fabbisogno ?? 0)),
+                    forecast_mw: Math.round(Number(r.forecast ?? r.previsione ?? 0)),
+                }));
+                return {
+                    dataset: "demand",
+                    source: "Terna Transparency (developer.terna.it)",
+                    date,
+                    zone,
+                    records,
+                };
+            }
+            case "exchanges": {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const exchanges = items.slice(0, 20).map((r) => {
+                    const flow = Number(r.flow ?? r.value ?? 0);
+                    return {
+                        border: r.border ?? r.country ?? r.confine ?? "Unknown",
+                        flow_mw: Math.round(flow),
+                        direction: flow >= 0 ? "import" : "export",
+                    };
+                });
+                const netImport = exchanges.reduce((s, e) => s + e.flow_mw, 0);
+                return {
+                    dataset: "exchanges",
+                    source: "Terna Transparency (developer.terna.it)",
+                    date,
+                    exchanges,
+                    net_import_mw: netImport,
+                };
+            }
+            case "market_data": {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const records = items.slice(0, 24).map((r) => ({
+                    zone: r.zone ?? r.zona ?? zone,
+                    timestamp: r.timestamp ?? r.datetime ?? "",
+                    price_eur_mwh: Math.round((Number(r.price ?? r.prezzo ?? 0)) * 100) / 100,
+                }));
+                return {
+                    dataset: "market_data",
+                    source: "Terna Transparency (developer.terna.it)",
+                    date,
+                    zone,
+                    records,
+                };
+            }
+        }
+    }
+    catch {
+        // Fallback with reference info
+        const description = `Italian ${params.dataset} data for ${date}. ` +
+            `Terna publishes real-time data at ${TERNA_PUBLIC}. ` +
+            "Developer API: developer.terna.it. " +
+            "Also available via ENTSO-E (get_generation_mix, get_day_ahead_prices) with zone IT.";
+        switch (params.dataset) {
+            case "generation":
+                return {
+                    dataset: "generation",
+                    source: "Terna Transparency (reference)",
+                    date,
+                    zone,
+                    records: [],
+                    latest: null,
+                };
+            case "demand":
+                return { dataset: "demand", source: "Terna (reference)", date, zone, records: [] };
+            case "exchanges":
+                return { dataset: "exchanges", source: "Terna (reference)", date, exchanges: [], net_import_mw: 0 };
+            case "market_data":
+                return { dataset: "market_data", source: "Terna (reference)", date, zone, records: [] };
+        }
+    }
+}

package/dist/tools/terrain-analysis.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { type GisSourceMetadata } from "../lib/gis-sources.js";
+export declare const terrainAnalysisSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lon: z.ZodNumber;
+}, z.core.$strip>;
+interface TerrainResult {
+    lat: number;
+    lon: number;
+    elevation_m: number;
+    slope_deg: number;
+    aspect_deg: number;
+    aspect_cardinal: string;
+    flatness_score: number;
+    source: string;
+    source_metadata: GisSourceMetadata;
+}
+export declare function getTerrainAnalysis(params: z.infer<typeof terrainAnalysisSchema>): Promise<TerrainResult>;
+export {};

package/dist/tools/terrain-analysis.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+import { GIS_SOURCES } from "../lib/gis-sources.js";
+const ELEVATION_URL = "https://api.open-meteo.com/v1/elevation";
+const cache = new TtlCache();
+/** Spacing between grid points in degrees (~30m at mid-latitudes). */
+const GRID_STEP_DEG = 0.0003;
+export const terrainAnalysisSchema = z.object({
+    lat: z
+        .number()
+        .describe("Latitude (-90 to 90). WGS84."),
+    lon: z
+        .number()
+        .describe("Longitude (-180 to 180). WGS84."),
+});
+/**
+ * Convert aspect angle (radians, math convention) to cardinal direction.
+ * 0° = North, 90° = East, 180° = South, 270° = West.
+ */
+function toCardinal(deg) {
+    const directions = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"];
+    const index = Math.round(deg / 45) % 8;
+    return directions[index];
+}
+/**
+ * Compute slope and aspect from a 3x3 elevation grid using Horn's method.
+ *
+ * Grid layout (row-major):
+ *   NW  N  NE     [0] [1] [2]
+ *    W  C   E     [3] [4] [5]
+ *   SW  S  SE     [6] [7] [8]
+ *
+ * cellSizeX/cellSizeY are the distances between adjacent cells in metres.
+ */
+function computeSlopeAspect(grid, cellSizeXM, cellSizeYM) {
+    const [nw, n, ne, w, , e, sw, s, se] = grid;
+    // Horn's method partial derivatives
+    const dzdx = ((ne + 2 * e + se) - (nw + 2 * w + sw)) / (8 * cellSizeXM);
+    const dzdy = ((nw + 2 * n + ne) - (sw + 2 * s + se)) / (8 * cellSizeYM);
+    const slopeRad = Math.atan(Math.sqrt(dzdx * dzdx + dzdy * dzdy));
+    const slopeDeg = slopeRad * (180 / Math.PI);
+    let aspectDeg;
+    if (dzdx === 0 && dzdy === 0) {
+        aspectDeg = 0; // flat — aspect undefined, default to north
+    }
+    else {
+        // atan2(-dzdy, -dzdx) gives angle from east; convert to compass bearing
+        let aspectRad = Math.atan2(-dzdy, -dzdx);
+        aspectDeg = aspectRad * (180 / Math.PI);
+        // Convert from math angle (E=0, CCW) to compass (N=0, CW)
+        aspectDeg = (90 - aspectDeg + 360) % 360;
+    }
+    // Flatness: 1.0 = perfectly flat, 0.0 = vertical (90° slope)
+    const flatness = 1 - slopeDeg / 90;
+    return {
+        slope_deg: Math.round(slopeDeg * 100) / 100,
+        aspect_deg: Math.round(aspectDeg * 100) / 100,
+        aspect_cardinal: toCardinal(aspectDeg),
+        flatness_score: Math.round(flatness * 100) / 100,
+    };
+}
+/**
+ * Approximate metres per degree of longitude at a given latitude.
+ */
+function metresPerDegreeLon(lat) {
+    return 111_320 * Math.cos(lat * (Math.PI / 180));
+}
+const METRES_PER_DEGREE_LAT = 111_320;
+export async function getTerrainAnalysis(params) {
+    const { lat, lon } = params;
+    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.");
+    const cacheKey = `terrain:${lat}:${lon}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    // Build 3x3 grid coordinates around the target point.
+    // Row order: north to south (dy: +1, 0, -1) so indices match
+    // the NW/N/NE, W/C/E, SW/S/SE layout expected by computeSlopeAspect.
+    const lats = [];
+    const lons = [];
+    for (let dy = 1; dy >= -1; dy--) {
+        for (let dx = -1; dx <= 1; dx++) {
+            lats.push(lat + dy * GRID_STEP_DEG);
+            lons.push(lon + dx * GRID_STEP_DEG);
+        }
+    }
+    const url = new URL(ELEVATION_URL);
+    url.searchParams.set("latitude", lats.join(","));
+    url.searchParams.set("longitude", lons.join(","));
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Open-Meteo Elevation API returned ${response.status}: ${body.slice(0, 300)}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const json = await response.json();
+    const elevations = json.elevation;
+    if (!Array.isArray(elevations) || elevations.length !== 9) {
+        throw new Error("Unexpected response from Open-Meteo Elevation API: expected 9 elevation values.");
+    }
+    const cellSizeXM = GRID_STEP_DEG * metresPerDegreeLon(lat);
+    const cellSizeYM = GRID_STEP_DEG * METRES_PER_DEGREE_LAT;
+    const { slope_deg, aspect_deg, aspect_cardinal, flatness_score } = computeSlopeAspect(elevations, cellSizeXM, cellSizeYM);
+    const result = {
+        lat,
+        lon,
+        elevation_m: elevations[4], // centre point
+        slope_deg,
+        aspect_deg,
+        aspect_cardinal,
+        flatness_score,
+        source: "open-meteo-elevation",
+        source_metadata: GIS_SOURCES["open-meteo-elevation"],
+    };
+    cache.set(cacheKey, result, TTL.STATIC_DATA);
+    return result;
+}

package/dist/tools/transfer-capacity.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const transferCapacitySchema: z.ZodObject<{
+    from_zone: z.ZodString;
+    to_zone: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface CapacityPoint {
+    hour: number;
+    ntc_mw: number;
+}
+export declare function getTransferCapacity(params: z.infer<typeof transferCapacitySchema>): Promise<{
+    from_zone: string;
+    to_zone: string;
+    date: string;
+    capacities: CapacityPoint[];
+    stats: {
+        min: number;
+        max: number;
+        mean: number;
+    };
+}>;
+export {};

package/dist/tools/transfer-capacity.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { queryEntsoe, dayRange } from "../lib/entsoe-client.js";
+import { resolveZone, AVAILABLE_ZONES } from "../lib/zone-codes.js";
+import { ensureArray } from "../lib/xml-parser.js";
+import { TTL } from "../lib/cache.js";
+export const transferCapacitySchema = z.object({
+    from_zone: z
+        .string()
+        .describe(`Exporting zone. Available: ${AVAILABLE_ZONES}`),
+    to_zone: z
+        .string()
+        .describe(`Importing zone. Available: ${AVAILABLE_ZONES}`),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+});
+export async function getTransferCapacity(params) {
+    const fromEic = resolveZone(params.from_zone);
+    const toEic = resolveZone(params.to_zone);
+    const { periodStart, periodEnd } = dayRange(params.date);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = await queryEntsoe({
+        documentType: "A61",
+        processType: "A01",
+        in_Domain: toEic,
+        out_Domain: fromEic,
+        periodStart,
+        periodEnd,
+    }, TTL.PRICES);
+    const doc = data.Publication_MarketDocument;
+    if (!doc)
+        throw new Error("No transfer capacity data returned for this corridor/date.");
+    const timeSeries = ensureArray(doc.TimeSeries);
+    const capacities = [];
+    for (const ts of timeSeries) {
+        const periods = ensureArray(ts.Period);
+        for (const period of periods) {
+            const points = ensureArray(period.Point);
+            for (const point of points) {
+                const position = Number(point.position);
+                const ntcMw = Number(point.quantity ?? 0);
+                capacities.push({ hour: position - 1, ntc_mw: ntcMw });
+            }
+        }
+    }
+    capacities.sort((a, b) => a.hour - b.hour);
+    const values = capacities.map((c) => c.ntc_mw);
+    const min = values.length > 0 ? Math.min(...values) : 0;
+    const max = values.length > 0 ? Math.max(...values) : 0;
+    const mean = values.length > 0
+        ? Math.round((values.reduce((s, v) => s + v, 0) / values.length) * 100) / 100
+        : 0;
+    return {
+        from_zone: params.from_zone.toUpperCase(),
+        to_zone: params.to_zone.toUpperCase(),
+        date: params.date ?? new Date().toISOString().slice(0, 10),
+        capacities,
+        stats: { min, max, mean },
+    };
+}

package/dist/tools/transmission.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const transmissionSchema: z.ZodObject<{
+    country: z.ZodOptional<z.ZodString>;
+    lat_min: z.ZodOptional<z.ZodNumber>;
+    lon_min: z.ZodOptional<z.ZodNumber>;
+    lat_max: z.ZodOptional<z.ZodNumber>;
+    lon_max: z.ZodOptional<z.ZodNumber>;
+    min_voltage_kv: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface TransmissionLine {
+    id: number;
+    voltage_kv: number;
+    operator: string | null;
+    cables: number | null;
+    coordinates: Array<{
+        lat: number;
+        lon: number;
+    }>;
+}
+type Bbox = [number, number, number, number];
+/** Split a bbox into smaller tiles of approximately TILE_SIZE_DEG x TILE_SIZE_DEG. */
+export declare function generateTiles(bbox: Bbox): Bbox[];
+export declare function getTransmissionLines(params: z.infer<typeof transmissionSchema>): Promise<{
+    bbox: Bbox;
+    line_count: number;
+    lines: TransmissionLine[];
+}>;
+export {};

package/dist/tools/transmission.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+import { COUNTRY_BBOXES } from "../lib/zone-codes.js";
+import { fetchOverpassJson } from "../lib/overpass.js";
+const cache = new TtlCache();
+export const transmissionSchema = z.object({
+    country: z
+        .string()
+        .optional()
+        .describe(`Country code to look up bounding box. Available: ${Object.keys(COUNTRY_BBOXES).join(", ")}. ` +
+        "Use this OR provide lat/lon bounds directly."),
+    lat_min: z.number().optional().describe("Southern latitude bound."),
+    lon_min: z.number().optional().describe("Western longitude bound."),
+    lat_max: z.number().optional().describe("Northern latitude bound."),
+    lon_max: z.number().optional().describe("Eastern longitude bound."),
+    min_voltage_kv: z
+        .number()
+        .optional()
+        .describe("Minimum voltage in kV to filter lines. Defaults to 220 (high-voltage only)."),
+    limit: z
+        .number()
+        .optional()
+        .describe("Maximum number of lines to return. Defaults to 100."),
+});
+// ---------------------------------------------------------------------------
+// Tiling helpers
+// ---------------------------------------------------------------------------
+/** Area threshold in square degrees above which we split into tiles. */
+const TILE_AREA_THRESHOLD = 25;
+/** Target tile size in degrees per side. */
+const TILE_SIZE_DEG = 5;
+/** Max concurrent tile queries to avoid Overpass rate limiting. */
+const TILE_CONCURRENCY = 2;
+/** Split a bbox into smaller tiles of approximately TILE_SIZE_DEG x TILE_SIZE_DEG. */
+export function generateTiles(bbox) {
+    const [latMin, lonMin, latMax, lonMax] = bbox;
+    const latRange = latMax - latMin;
+    const lonRange = lonMax - lonMin;
+    const latSteps = Math.ceil(latRange / TILE_SIZE_DEG);
+    const lonSteps = Math.ceil(lonRange / TILE_SIZE_DEG);
+    const latStep = latRange / latSteps;
+    const lonStep = lonRange / lonSteps;
+    const tiles = [];
+    for (let i = 0; i < latSteps; i++) {
+        for (let j = 0; j < lonSteps; j++) {
+            tiles.push([
+                latMin + i * latStep,
+                lonMin + j * lonStep,
+                latMin + (i + 1) * latStep,
+                lonMin + (j + 1) * lonStep,
+            ]);
+        }
+    }
+    return tiles;
+}
+/** Returns true if the bbox area exceeds the tiling threshold. */
+function shouldTile(bbox) {
+    const latRange = bbox[2] - bbox[0];
+    const lonRange = bbox[3] - bbox[1];
+    return latRange * lonRange > TILE_AREA_THRESHOLD;
+}
+/** Query a single bbox tile and return raw Overpass elements. */
+async function queryTile(bbox) {
+    const bboxStr = `${bbox[0]},${bbox[1]},${bbox[2]},${bbox[3]}`;
+    const query = `[out:json][timeout:30];way["power"="line"]["voltage"](${bboxStr});out geom;`;
+    const json = await fetchOverpassJson(query);
+    return Array.isArray(json.elements) ? json.elements : [];
+}
+/**
+ * Query multiple tiles with bounded concurrency.
+ * Runs at most `concurrency` queries in parallel.
+ */
+async function queryTilesWithConcurrency(tiles, concurrency) {
+    const allElements = [];
+    const remaining = [...tiles];
+    while (remaining.length > 0) {
+        const batch = remaining.splice(0, concurrency);
+        const results = await Promise.all(batch.map(queryTile));
+        for (const elements of results) {
+            allElements.push(...elements);
+        }
+    }
+    return allElements;
+}
+/** Parse raw Overpass elements into TransmissionLine[], filtering by voltage. */
+function parseElements(elements, minVoltageV) {
+    const lines = [];
+    for (const el of elements) {
+        const voltageStr = el.tags?.voltage ?? "0";
+        const voltageV = Number(voltageStr.split(";")[0]);
+        if (voltageV < minVoltageV)
+            continue;
+        const coords = Array.isArray(el.geometry)
+            ? el.geometry.map((g) => ({ lat: g.lat, lon: g.lon }))
+            : [];
+        lines.push({
+            id: el.id,
+            voltage_kv: Math.round(voltageV / 1000),
+            operator: el.tags?.operator ?? null,
+            cables: el.tags?.cables ? Number(el.tags.cables) : null,
+            coordinates: coords,
+        });
+    }
+    return lines;
+}
+/** Deduplicate lines by OSM way ID (tiles may overlap at boundaries). */
+function deduplicateById(lines) {
+    const seen = new Map();
+    for (const line of lines) {
+        if (!seen.has(line.id)) {
+            seen.set(line.id, line);
+        }
+    }
+    return [...seen.values()];
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export async function getTransmissionLines(params) {
+    let bbox;
+    if (params.country) {
+        const upper = params.country.toUpperCase();
+        const countryBbox = COUNTRY_BBOXES[upper];
+        if (!countryBbox) {
+            throw new Error(`No bounding box for "${upper}". Available: ${Object.keys(COUNTRY_BBOXES).join(", ")}`);
+        }
+        bbox = countryBbox;
+    }
+    else if (params.lat_min != null &&
+        params.lon_min != null &&
+        params.lat_max != null &&
+        params.lon_max != null) {
+        bbox = [params.lat_min, params.lon_min, params.lat_max, params.lon_max];
+    }
+    else {
+        throw new Error("Provide either 'country' or all four bounding box parameters.");
+    }
+    const minVoltageV = (params.min_voltage_kv ?? 220) * 1000;
+    const maxResults = params.limit ?? 100;
+    const cacheKey = `overpass:${bbox.join(",")}:${minVoltageV}:${maxResults}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    let rawElements;
+    if (shouldTile(bbox)) {
+        const tiles = generateTiles(bbox);
+        rawElements = await queryTilesWithConcurrency(tiles, TILE_CONCURRENCY);
+    }
+    else {
+        rawElements = await queryTile(bbox);
+    }
+    let lines = parseElements(rawElements, minVoltageV);
+    lines = deduplicateById(lines);
+    lines.sort((a, b) => b.voltage_kv - a.voltage_kv);
+    lines = lines.slice(0, maxResults);
+    const result = { bbox, line_count: lines.length, lines };
+    cache.set(cacheKey, result, TTL.STATIC_DATA);
+    return result;
+}

package/dist/tools/uk-carbon.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare const ukCarbonSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        date: "date";
+        regional: "regional";
+        current: "current";
+    }>;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface FuelMix {
+    fuel: string;
+    perc: number;
+}
+interface CarbonCurrent {
+    action: "current";
+    timestamp: string;
+    intensity_gco2_kwh: number;
+    index: string;
+    generation_mix: FuelMix[];
+}
+interface RegionEntry {
+    region: string;
+    intensity_gco2_kwh: number;
+    index: string;
+    generation_mix: FuelMix[];
+}
+interface CarbonRegional {
+    action: "regional";
+    timestamp: string;
+    regions: RegionEntry[];
+}
+interface HalfHourEntry {
+    from: string;
+    to: string;
+    intensity_forecast: number;
+    intensity_actual: number | null;
+    index: string;
+}
+interface CarbonDate {
+    action: "date";
+    date: string;
+    periods: HalfHourEntry[];
+    stats: {
+        mean_forecast: number;
+        min_forecast: number;
+        max_forecast: number;
+    };
+}
+type UkCarbonResult = CarbonCurrent | CarbonRegional | CarbonDate;
+export declare function getUkCarbonIntensity(params: z.infer<typeof ukCarbonSchema>): Promise<UkCarbonResult>;
+export {};