@iflow-mcp/kitfunso-luminus 0.2.0

package/dist/tools/power-plants.js

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import { TtlCache, TTL } from "../lib/cache.js";
+const CONVENTIONAL_URL = "https://data.open-power-system-data.org/conventional_power_plants/latest/conventional_power_plants_EU.csv";
+const RENEWABLE_URL = "https://data.open-power-system-data.org/renewable_power_plants/latest/renewable_power_plants_EU_DE.csv";
+// NESO publishes GB generation projects via two registers:
+// - TEC Register: transmission-connected (large) plants
+// - Embedded Register: distribution-connected (smaller/medium) plants
+const NESO_TEC_URL = "https://api.neso.energy/api/3/action/datastore_search?resource_id=17becbab-e3e8-473f-b303-3806f43a6a10&limit=5000";
+const NESO_EMBEDDED_URL = "https://api.neso.energy/api/3/action/package_show?id=embedded-register";
+const cache = new TtlCache();
+export const powerPlantsSchema = z.object({
+    country: z
+        .string()
+        .optional()
+        .describe("ISO country code to filter (e.g. DE, FR, GB). Returns all if omitted."),
+    fuel_type: z
+        .string()
+        .optional()
+        .describe("Fuel/energy type filter (e.g. Natural gas, Hard coal, Solar, Wind). Case-insensitive partial match."),
+    min_capacity_mw: z
+        .number()
+        .optional()
+        .describe("Minimum capacity in MW to include. Defaults to 0."),
+});
+function parseCsvRows(csv) {
+    const lines = csv.split("\n");
+    if (lines.length < 2)
+        return [];
+    const headers = parseCsvLine(lines[0]);
+    const rows = [];
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const values = parseCsvLine(line);
+        const row = {};
+        for (let j = 0; j < headers.length; j++) {
+            row[headers[j]] = values[j] ?? "";
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function parseCsvLine(line) {
+    const result = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (char === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                current += '"';
+                i++;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+        }
+        else if (char === "," && !inQuotes) {
+            result.push(current.trim());
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    result.push(current.trim());
+    return result;
+}
+async function fetchAndParsePlants(url, type) {
+    const cacheKey = `opsd:${type}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Open Power System Data returned ${response.status} for ${type} plants.`);
+    }
+    const csv = await response.text();
+    const rows = parseCsvRows(csv);
+    const plants = [];
+    for (const row of rows) {
+        const name = row["name"] ?? row["project_name"] ?? "";
+        const country = row["country"] ?? "";
+        const capacityStr = row["capacity_net_bnetza"] ?? row["capacity_gross_uba"] ??
+            row["electrical_capacity"] ?? row["capacity"] ?? "";
+        const capacity = parseFloat(capacityStr);
+        if (isNaN(capacity) || capacity <= 0)
+            continue;
+        const fuel = row["energy_source"] ?? row["fuel"] ?? row["technology"] ?? "";
+        const lat = parseFloat(row["lat"] ?? "");
+        const lon = parseFloat(row["lon"] ?? "");
+        const yearStr = row["commissioned"] ?? row["commissioning_date"] ?? "";
+        const year = parseInt(yearStr.slice(0, 4), 10);
+        plants.push({
+            name: name || "Unknown",
+            country: country.toUpperCase(),
+            capacity_mw: Math.round(capacity * 10) / 10,
+            fuel: fuel || "Unknown",
+            lat: isNaN(lat) ? null : lat,
+            lon: isNaN(lon) ? null : lon,
+            commissioned_year: isNaN(year) ? null : year,
+        });
+    }
+    cache.set(cacheKey, plants, TTL.STATIC_DATA);
+    return plants;
+}
+function dedupePlants(plants) {
+    const seen = new Set();
+    return plants.filter((plant) => {
+        const key = `${plant.country}:${plant.name}:${plant.capacity_mw}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+async function fetchGbPlantsFromNeso() {
+    const cacheKey = "neso:gb-plants";
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const plants = [];
+    // Fetch TEC register (transmission-connected)
+    try {
+        const tecResponse = await fetch(NESO_TEC_URL);
+        if (tecResponse.ok) {
+            const json = await tecResponse.json();
+            const records = json.result?.records ?? [];
+            for (const r of records) {
+                const mw = parseFloat(r["MW Connected"] ?? r["Cumulative Total Capacity (MW)"] ?? "0");
+                if (isNaN(mw) || mw <= 0)
+                    continue;
+                plants.push({
+                    name: r["Project Name"] ?? "Unknown",
+                    country: "GB",
+                    capacity_mw: Math.round(mw * 10) / 10,
+                    fuel: r["Plant Type"] ?? "Unknown",
+                    lat: null,
+                    lon: null,
+                    commissioned_year: null,
+                });
+            }
+        }
+    }
+    catch {
+        // TEC fetch failed, continue with embedded
+    }
+    // Fetch Embedded register (distribution-connected)
+    try {
+        const pkgResponse = await fetch(NESO_EMBEDDED_URL);
+        if (pkgResponse.ok) {
+            const pkgJson = await pkgResponse.json();
+            const resources = pkgJson.result?.resources ?? [];
+            const csvResource = resources.find((r) => r.format === "CSV");
+            if (csvResource?.url) {
+                const csvResponse = await fetch(csvResource.url);
+                if (csvResponse.ok) {
+                    const csv = await csvResponse.text();
+                    const rows = parseCsvRows(csv);
+                    for (const row of rows) {
+                        const mw = parseFloat(row["MW Connected"] ?? row["Cumulative Total Capacity (MW)"] ?? "0");
+                        if (isNaN(mw) || mw <= 0)
+                            continue;
+                        plants.push({
+                            name: row["Project Name"] ?? "Unknown",
+                            country: "GB",
+                            capacity_mw: Math.round(mw * 10) / 10,
+                            fuel: row["Plant Type"] ?? "Unknown",
+                            lat: null,
+                            lon: null,
+                            commissioned_year: null,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Embedded fetch failed
+    }
+    const deduped = dedupePlants(plants);
+    cache.set(cacheKey, deduped, TTL.STATIC_DATA);
+    return deduped;
+}
+export async function getPowerPlants(params) {
+    const minCap = params.min_capacity_mw ?? 0;
+    // Fetch both datasets concurrently
+    const [conventional, renewable] = await Promise.all([
+        fetchAndParsePlants(CONVENTIONAL_URL, "conventional").catch(() => []),
+        fetchAndParsePlants(RENEWABLE_URL, "renewable").catch(() => []),
+    ]);
+    let plants = [...conventional, ...renewable];
+    const shouldIncludeGb = !params.country || params.country.toUpperCase() === "GB";
+    if (shouldIncludeGb) {
+        const gbPlants = await fetchGbPlantsFromNeso();
+        plants = dedupePlants([...plants, ...gbPlants]);
+    }
+    // Apply filters
+    if (params.country) {
+        const countryUpper = params.country.toUpperCase();
+        plants = plants.filter((p) => p.country === countryUpper);
+    }
+    if (params.fuel_type) {
+        const fuelLower = params.fuel_type.toLowerCase();
+        plants = plants.filter((p) => p.fuel.toLowerCase().includes(fuelLower));
+    }
+    plants = plants.filter((p) => p.capacity_mw >= minCap);
+    // Sort by capacity descending
+    plants.sort((a, b) => b.capacity_mw - a.capacity_mw);
+    // Limit to top 200 to avoid huge responses
+    const limited = plants.slice(0, 200);
+    const total_capacity_mw = Math.round(plants.reduce((s, p) => s + p.capacity_mw, 0) * 10) / 10;
+    return {
+        filters: {
+            country: params.country?.toUpperCase(),
+            fuel_type: params.fuel_type,
+            min_capacity_mw: minCap,
+        },
+        total_count: plants.length,
+        plants: limited,
+        total_capacity_mw,
+    };
+}

package/dist/tools/price-spread-analysis.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const priceSpreadAnalysisSchema: z.ZodObject<{
+    zone: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+    efficiency: z.ZodOptional<z.ZodNumber>;
+    cycles: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface ScheduleEntry {
+    hour: number;
+    price: number;
+    action: "charge" | "discharge" | "hold";
+}
+type ArbSignal = "strong_arb" | "moderate_arb" | "weak_arb" | "no_arb";
+export declare function getPriceSpreadAnalysis(params: z.infer<typeof priceSpreadAnalysisSchema>): Promise<{
+    zone: string;
+    date: string;
+    efficiency: number;
+    targetCycles: number;
+    grossSpread: number;
+    netSpread: number;
+    revenuePerMwDay: number;
+    signal: ArbSignal;
+    peakPrice: number;
+    offPeakPrice: number;
+    schedule: ScheduleEntry[];
+}>;
+export {};

package/dist/tools/price-spread-analysis.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { getDayAheadPrices } from "./prices.js";
+import { AVAILABLE_ZONES } from "../lib/zone-codes.js";
+export const priceSpreadAnalysisSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Bidding zone code. Examples: DE, FR, GB. Available: ${AVAILABLE_ZONES}`),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+    efficiency: z
+        .number()
+        .optional()
+        .describe("Round-trip efficiency of the BESS (0-1). Defaults to 0.88."),
+    cycles: z
+        .number()
+        .optional()
+        .describe("Target charge/discharge cycles per day. Defaults to 2."),
+});
+export async function getPriceSpreadAnalysis(params) {
+    const efficiency = params.efficiency ?? 0.88;
+    const cycles = params.cycles ?? 2;
+    const date = params.date ?? new Date().toISOString().slice(0, 10);
+    const priceData = await getDayAheadPrices({
+        zone: params.zone,
+        start_date: date,
+    });
+    const prices = priceData.prices;
+    if (prices.length === 0) {
+        return {
+            zone: params.zone.toUpperCase(),
+            date,
+            efficiency,
+            targetCycles: cycles,
+            grossSpread: 0,
+            netSpread: 0,
+            revenuePerMwDay: 0,
+            signal: "no_arb",
+            peakPrice: 0,
+            offPeakPrice: 0,
+            schedule: [],
+        };
+    }
+    // Sort by price to find cheapest/most expensive hours
+    const sorted = [...prices].sort((a, b) => a.price_eur_mwh - b.price_eur_mwh);
+    const chargeCount = Math.min(cycles, sorted.length);
+    const dischargeCount = Math.min(cycles, sorted.length);
+    const chargeHours = new Set(sorted.slice(0, chargeCount).map((p) => p.hour));
+    const dischargeHours = new Set(sorted.slice(-dischargeCount).map((p) => p.hour));
+    // Resolve conflicts: if same hour appears in both, remove from charge
+    for (const h of chargeHours) {
+        if (dischargeHours.has(h)) {
+            chargeHours.delete(h);
+        }
+    }
+    const chargeAvg = sorted.slice(0, chargeCount).reduce((s, p) => s + p.price_eur_mwh, 0) / chargeCount;
+    const dischargeAvg = sorted.slice(-dischargeCount).reduce((s, p) => s + p.price_eur_mwh, 0) / dischargeCount;
+    const grossSpread = Math.round((dischargeAvg - chargeAvg) * 100) / 100;
+    // Net spread: discharge_price * efficiency - charge_price (efficiency loss on discharge side)
+    const netSpread = Math.round((dischargeAvg * efficiency - chargeAvg) * 100) / 100;
+    const revenuePerMwDay = Math.round(netSpread * cycles * 100) / 100;
+    let signal;
+    if (netSpread > 30)
+        signal = "strong_arb";
+    else if (netSpread > 15)
+        signal = "moderate_arb";
+    else if (netSpread > 5)
+        signal = "weak_arb";
+    else
+        signal = "no_arb";
+    const schedule = prices.map((p) => ({
+        hour: p.hour,
+        price: Math.round(p.price_eur_mwh * 100) / 100,
+        action: chargeHours.has(p.hour)
+            ? "charge"
+            : dischargeHours.has(p.hour)
+                ? "discharge"
+                : "hold",
+    }));
+    schedule.sort((a, b) => a.hour - b.hour);
+    const peakPrice = Math.round(Math.max(...prices.map((p) => p.price_eur_mwh)) * 100) / 100;
+    const offPeakPrice = Math.round(Math.min(...prices.map((p) => p.price_eur_mwh)) * 100) / 100;
+    return {
+        zone: params.zone.toUpperCase(),
+        date,
+        efficiency,
+        targetCycles: cycles,
+        grossSpread,
+        netSpread,
+        revenuePerMwDay,
+        signal,
+        peakPrice,
+        offPeakPrice,
+        schedule,
+    };
+}

package/dist/tools/prices.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const pricesSchema: z.ZodObject<{
+    zone: z.ZodString;
+    start_date: z.ZodOptional<z.ZodString>;
+    end_date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface PricePoint {
+    hour: number;
+    price_eur_mwh: number;
+}
+export declare function getDayAheadPrices(params: z.infer<typeof pricesSchema>): Promise<{
+    zone: string;
+    start_date: string;
+    end_date: string;
+    currency: string;
+    prices: PricePoint[];
+    stats: {
+        min: number;
+        max: number;
+        mean: number;
+    };
+}>;
+export {};

package/dist/tools/prices.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { queryEntsoe, dayRange, formatEntsoeDate } from "../lib/entsoe-client.js";
+import { resolvePriceZone, AVAILABLE_ZONES } from "../lib/zone-codes.js";
+import { ensureArray } from "../lib/xml-parser.js";
+import { TTL } from "../lib/cache.js";
+export const pricesSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Bidding zone code. Examples: DE, FR, GB. Available: ${AVAILABLE_ZONES}`),
+    start_date: z
+        .string()
+        .optional()
+        .describe("Start date YYYY-MM-DD. Defaults to today."),
+    end_date: z
+        .string()
+        .optional()
+        .describe("End date YYYY-MM-DD. Defaults to start_date + 1 day."),
+});
+export async function getDayAheadPrices(params) {
+    const eic = resolvePriceZone(params.zone);
+    let periodStart;
+    let periodEnd;
+    if (params.start_date) {
+        const startDt = new Date(params.start_date + "T00:00:00Z");
+        periodStart = formatEntsoeDate(startDt);
+        if (params.end_date) {
+            const endDt = new Date(params.end_date + "T00:00:00Z");
+            periodEnd = formatEntsoeDate(endDt);
+        }
+        else {
+            periodEnd = formatEntsoeDate(new Date(startDt.getTime() + 24 * 60 * 60 * 1000));
+        }
+    }
+    else {
+        const range = dayRange();
+        periodStart = range.periodStart;
+        periodEnd = range.periodEnd;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = await queryEntsoe({
+        documentType: "A44",
+        in_Domain: eic,
+        out_Domain: eic,
+        periodStart,
+        periodEnd,
+    }, TTL.PRICES);
+    const doc = data.Publication_MarketDocument;
+    if (!doc)
+        throw new Error("No price data returned for this zone/date range.");
+    const timeSeries = ensureArray(doc.TimeSeries);
+    const prices = [];
+    for (const ts of timeSeries) {
+        const currency = ts["currency_Unit.name"] ?? "EUR";
+        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 price = Number(point["price.amount"]);
+                prices.push({ hour: position - 1, price_eur_mwh: price });
+            }
+        }
+    }
+    prices.sort((a, b) => a.hour - b.hour);
+    const values = prices.map((p) => p.price_eur_mwh);
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const mean = values.length > 0
+        ? Math.round((values.reduce((s, v) => s + v, 0) / values.length) * 100) / 100
+        : 0;
+    return {
+        zone: params.zone.toUpperCase(),
+        start_date: params.start_date ?? new Date().toISOString().slice(0, 10),
+        end_date: params.end_date ?? params.start_date ?? new Date().toISOString().slice(0, 10),
+        currency: "EUR",
+        prices,
+        stats: { min, max, mean },
+    };
+}

package/dist/tools/realtime-generation.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const realtimeGenerationSchema: z.ZodObject<{
+    zone: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface GenerationEntry {
+    fuel: string;
+    fuel_code: string;
+    generation_mw: number;
+}
+interface RealtimeGenerationResult {
+    zone: string;
+    date: string;
+    generation: GenerationEntry[];
+    total_mw: number;
+    timestamp: string;
+}
+export declare function getRealtimeGeneration(params: z.infer<typeof realtimeGenerationSchema>): Promise<RealtimeGenerationResult>;
+export {};

package/dist/tools/realtime-generation.js

@@ -0,0 +1,141 @@
+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 { TtlCache, TTL } from "../lib/cache.js";
+const ELEXON_API = "https://data.elexon.co.uk/bmrs/api/v1";
+const cache = new TtlCache();
+export const realtimeGenerationSchema = z.object({
+    zone: z
+        .string()
+        .describe(`Country/zone code. Examples: DE, FR, GB. Available: ${AVAILABLE_ZONES}`),
+    date: z
+        .string()
+        .optional()
+        .describe("Date in YYYY-MM-DD format. Defaults to today."),
+});
+/** ENTSO-E PSR type codes to human-readable fuel names */
+const PSR_TYPES = {
+    B01: "Biomass",
+    B02: "Lignite",
+    B04: "Gas",
+    B05: "Coal",
+    B06: "Oil",
+    B09: "Geothermal",
+    B10: "Hydro Pumped Storage",
+    B11: "Hydro Run-of-river",
+    B12: "Hydro Reservoir",
+    B14: "Nuclear",
+    B15: "Other",
+    B16: "Solar",
+    B17: "Waste",
+    B18: "Wind Offshore",
+    B19: "Wind Onshore",
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function fetchElexon(path) {
+    const url = `${ELEXON_API}${path}`;
+    const cached = cache.get(url);
+    if (cached)
+        return cached;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Elexon BMRS API returned ${response.status}: ${body.slice(0, 300)}`);
+    }
+    const json = await response.json();
+    cache.set(url, json, TTL.REALTIME);
+    return json;
+}
+async function getGbGeneration(date) {
+    const data = await fetchElexon(`/datasets/FUELHH?format=json`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const rows = data?.data ?? [];
+    if (rows.length === 0) {
+        throw new Error("No GB generation data available from Elexon BMRS.");
+    }
+    // Group by fuelType, take latest settlement period
+    const latestPeriod = Math.max(...rows.map((r) => Number(r.settlementPeriod ?? 0)));
+    const latestRows = rows.filter((r) => Number(r.settlementPeriod) === latestPeriod);
+    const generation = [];
+    for (const row of latestRows) {
+        const fuelType = String(row.fuelType ?? "Unknown");
+        const mw = Number(row.generation ?? 0);
+        if (mw > 0) {
+            generation.push({
+                fuel: fuelType,
+                fuel_code: fuelType,
+                generation_mw: Math.round(mw),
+            });
+        }
+    }
+    generation.sort((a, b) => b.generation_mw - a.generation_mw);
+    const total_mw = generation.reduce((sum, g) => sum + g.generation_mw, 0);
+    const timestamp = latestRows[0]?.startTime ?? new Date().toISOString();
+    return {
+        zone: "GB",
+        date,
+        generation,
+        total_mw,
+        timestamp,
+    };
+}
+async function getEntsoeGeneration(zone, date) {
+    const eic = resolveZone(zone);
+    const { periodStart, periodEnd } = dayRange(date);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = await queryEntsoe({
+        documentType: "A75",
+        processType: "A16",
+        in_Domain: eic,
+        periodStart,
+        periodEnd,
+    }, TTL.REALTIME);
+    const doc = data.GL_MarketDocument;
+    if (!doc)
+        throw new Error("No realtime generation data returned for this zone/date.");
+    const timeSeries = ensureArray(doc.TimeSeries);
+    const generation = [];
+    let latestTimestamp = "";
+    for (const ts of timeSeries) {
+        const psrCode = ts.MktPSRType?.psrType ?? "unknown";
+        const fuel = PSR_TYPES[psrCode] ?? psrCode;
+        const periods = ensureArray(ts.Period);
+        const lastPeriod = periods[periods.length - 1];
+        if (!lastPeriod)
+            continue;
+        // Track the period start for timestamp
+        const periodStartStr = lastPeriod.timeInterval?.start ?? "";
+        if (periodStartStr > latestTimestamp) {
+            latestTimestamp = periodStartStr;
+        }
+        const points = ensureArray(lastPeriod.Point);
+        if (points.length === 0)
+            continue;
+        const latestPoint = points[points.length - 1];
+        const mw = Number(latestPoint.quantity ?? 0);
+        if (mw > 0) {
+            generation.push({
+                fuel,
+                fuel_code: psrCode,
+                generation_mw: Math.round(mw),
+            });
+        }
+    }
+    generation.sort((a, b) => b.generation_mw - a.generation_mw);
+    const total_mw = generation.reduce((sum, g) => sum + g.generation_mw, 0);
+    return {
+        zone: zone.toUpperCase(),
+        date: date ?? new Date().toISOString().slice(0, 10),
+        generation,
+        total_mw,
+        timestamp: latestTimestamp || new Date().toISOString(),
+    };
+}
+export async function getRealtimeGeneration(params) {
+    const date = params.date ?? new Date().toISOString().slice(0, 10);
+    if (params.zone.toUpperCase() === "GB") {
+        return getGbGeneration(date);
+    }
+    return getEntsoeGeneration(params.zone, params.date);
+}

package/dist/tools/ree-esios.d.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+export declare const reeEsiosSchema: z.ZodObject<{
+    dataset: z.ZodEnum<{
+        generation: "generation";
+        demand: "demand";
+        day_ahead_price: "day_ahead_price";
+        wind_solar: "wind_solar";
+        interconnectors: "interconnectors";
+    }>;
+    date: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface PriceRecord {
+    timestamp: string;
+    price_eur_mwh: number;
+}
+interface SpainPricesResult {
+    dataset: "day_ahead_price";
+    source: string;
+    date: string;
+    records: PriceRecord[];
+    stats: {
+        min: number;
+        max: number;
+        mean: number;
+    };
+}
+interface DemandRecord {
+    timestamp: string;
+    forecast_mw: number;
+    actual_mw: number;
+    error_mw: number;
+}
+interface SpainDemandResult {
+    dataset: "demand";
+    source: string;
+    date: string;
+    records: DemandRecord[];
+}
+interface GenMixRecord {
+    timestamp: string;
+    technology: string;
+    generation_mw: number;
+}
+interface SpainGenerationResult {
+    dataset: "generation";
+    source: string;
+    date: string;
+    records: GenMixRecord[];
+}
+interface WindSolarRecord {
+    timestamp: string;
+    wind_forecast_mw: number;
+    wind_actual_mw: number;
+    solar_forecast_mw: number;
+    solar_actual_mw: number;
+}
+interface SpainWindSolarResult {
+    dataset: "wind_solar";
+    source: string;
+    date: string;
+    records: WindSolarRecord[];
+}
+interface InterconnectorRecord {
+    border: string;
+    flow_mw: number;
+    direction: string;
+    timestamp: string;
+}
+interface SpainInterconnectorsResult {
+    dataset: "interconnectors";
+    source: string;
+    date: string;
+    records: InterconnectorRecord[];
+    net_import_mw: number;
+}
+type ReeEsiosResult = SpainPricesResult | SpainDemandResult | SpainGenerationResult | SpainWindSolarResult | SpainInterconnectorsResult;
+export declare function getReeEsios(params: z.infer<typeof reeEsiosSchema>): Promise<ReeEsiosResult>;
+export {};