@enyo-energy/energy-app-sdk 1.2.0 → 1.3.0

package/dist/cjs/types/enyo-grid-fee.d.cts

@@ -0,0 +1,129 @@
+import { EnyoCurrencyEnum } from './enyo-currency.cjs';
+import { ForecastResolutionEnum } from './enyo-forecasting.cjs';
+import { EnyoPriceAppliesToEnum, EnyoPriceSchedule } from './enyo-price-schedule.cjs';
+/**
+ * A registered dynamic grid fee (network charge).
+ *
+ * A grid fee is the component of the electricity price the grid operator (DSO)
+ * charges for transporting the energy. Historically it was a single constant
+ * ct/kWh value; with time-variable network charges (e.g. §14a EnWG module 3 in
+ * Germany) it varies by time of day, weekday and season, and grid operators
+ * increasingly publish it as a dated series.
+ *
+ * A fee registered here is **not** automatically applied to any price. It is
+ * published so that energy apps can read it via
+ * {@link EnergyAppGridFee.getDynamicGridFees} and compose the effective
+ * electricity price themselves — see `composeElectricityPrices()`. This is
+ * deliberate: some tariff providers already return grid-fee-inclusive prices
+ * from their own API and must not add the fee a second time.
+ */
+export interface EnyoDynamicGridFee {
+    /** Unique identifier of this grid fee. */
+    id: string;
+    /** Human-readable name, e.g. `'Netzentgelt HT/NT 2026'`. */
+    name: string;
+    /** Name of the grid operator (DSO) that publishes this fee. */
+    gridOperator: string;
+    /** Currency of every amount in {@link schedule}. */
+    currency: EnyoCurrencyEnum;
+    /**
+     * IANA time zone the schedule's wall-clock times are expressed in, e.g.
+     * `'Europe/Berlin'`. Required — network charge windows are published in
+     * local time and must survive daylight-saving transitions.
+     */
+    timezone: string;
+    /** Whether the fee applies to consumption, feed-in, or both. */
+    appliesTo: EnyoPriceAppliesToEnum;
+    /** When and how much the fee is. Amounts are positive and **added** to the energy price. */
+    schedule: EnyoPriceSchedule;
+    /** Optional start of the fee's validity in ISO format (inclusive). */
+    validFromIso?: string;
+    /** Optional end of the fee's validity in ISO format (exclusive). */
+    validUntilIso?: string;
+    /** Optional metering point this fee is bound to (e.g. a German Marktlokations-ID). */
+    meteringPointId?: string;
+    /**
+     * Marks the fee as a time-variable network charge under §14a EnWG module 3.
+     * Purely informational — it does not change how the fee is resolved.
+     */
+    moduleThreeCompliant?: boolean;
+    /** When the fee was last registered or updated, in ISO format. Set by the host. */
+    publishedAtIso?: string;
+}
+/**
+ * Registration payload for {@link EnergyAppGridFee.registerGridFee}.
+ * `publishedAtIso` is assigned by the host and therefore not part of the input.
+ */
+export type EnyoDynamicGridFeeRegistration = Omit<EnyoDynamicGridFee, 'publishedAtIso'>;
+/**
+ * One resolved 15-minute interval of a dynamic grid fee.
+ */
+export interface EnyoDynamicGridFeeEntry {
+    /** Start of the 15-minute interval in ISO format. */
+    timestampIso: string;
+    /**
+     * Grid fee per kWh for this interval, in the series' currency. Always
+     * `>= 0`; `0` for intervals no window covers.
+     */
+    feePerKwh: number;
+}
+/**
+ * A dynamic grid fee resolved to a flat 15-minute series over a requested range.
+ *
+ * The resolution matches {@link EnergyAppEnergyPrices.getPrices}, so entries can
+ * be zipped with a price series index-by-index once both cover the same range.
+ */
+export interface EnyoDynamicGridFeeSeries {
+    /** Identifier of the grid fee this series was resolved from. */
+    gridFeeId: string;
+    /** Currency of every amount in {@link entries}. */
+    currency: EnyoCurrencyEnum;
+    /** Always {@link ForecastResolutionEnum.FifteenMinutes} — present for symmetry with other price APIs. */
+    resolution: ForecastResolutionEnum;
+    /** IANA time zone the underlying schedule was resolved in. */
+    timezone: string;
+    /** Direction the fee applies to. */
+    appliesTo: EnyoPriceAppliesToEnum;
+    /** Resolved entries sorted ascending by `timestampIso`, without gaps. */
+    entries: EnyoDynamicGridFeeEntry[];
+}
+/**
+ * Selects which grid fee to resolve, and over which range.
+ *
+ * A grid fee belongs to the site's grid connection, not to a supplier contract —
+ * so there is deliberately no tariff selector here. With no selector at all, the
+ * grid fee that applies to this device is resolved.
+ */
+export interface EnyoDynamicGridFeeFilter {
+    /** Start of the requested range in ISO format (inclusive). */
+    fromIso: string;
+    /** End of the requested range in ISO format (exclusive). */
+    untilIso: string;
+    /** Resolve this specific grid fee. */
+    gridFeeId?: string;
+    /** Resolve the grid fee registered for this metering point. */
+    meteringPointId?: string;
+}
+/**
+ * What happened to a grid fee registration.
+ */
+export declare enum EnyoGridFeeChangeTypeEnum {
+    /** A new grid fee was registered. */
+    Registered = "registered",
+    /** An existing grid fee's attributes or schedule changed. */
+    Updated = "updated",
+    /** A grid fee was removed. */
+    Removed = "removed"
+}
+/**
+ * Event delivered to listeners registered via
+ * {@link EnergyAppGridFee.onGridFeeChanged}.
+ */
+export interface EnyoGridFeeChangeEvent {
+    /** What happened. */
+    changeType: EnyoGridFeeChangeTypeEnum;
+    /** Identifier of the affected grid fee. */
+    gridFeeId: string;
+    /** The grid fee after the change, or `null` when it was removed. */
+    gridFee: EnyoDynamicGridFee | null;
+}

package/dist/cjs/types/enyo-price-composition.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnyoPriceComponentOriginEnum = void 0;
+/**
+ * Where a price component in a composed entry came from.
+ */
+var EnyoPriceComponentOriginEnum;
+(function (EnyoPriceComponentOriginEnum) {
+    /** The component was already contained in the energy price series. */
+    EnyoPriceComponentOriginEnum["Included"] = "included";
+    /** The component was added by the composer on top of the energy price. */
+    EnyoPriceComponentOriginEnum["Added"] = "added";
+    /** No such component applies to this interval. */
+    EnyoPriceComponentOriginEnum["NotApplicable"] = "not-applicable";
+})(EnyoPriceComponentOriginEnum || (exports.EnyoPriceComponentOriginEnum = EnyoPriceComponentOriginEnum = {}));

package/dist/cjs/types/enyo-price-composition.d.cts

@@ -0,0 +1,126 @@
+import { EnyoTariffBonus, TariffPriceCompositionInfo } from './enyo-electricity-tariff.cjs';
+import { EnyoDynamicGridFeeSeries } from './enyo-grid-fee.cjs';
+import { EnyoPriceAppliesToEnum } from './enyo-price-schedule.cjs';
+/**
+ * Where a price component in a composed entry came from.
+ */
+export declare enum EnyoPriceComponentOriginEnum {
+    /** The component was already contained in the energy price series. */
+    Included = "included",
+    /** The component was added by the composer on top of the energy price. */
+    Added = "added",
+    /** No such component applies to this interval. */
+    NotApplicable = "not-applicable"
+}
+/**
+ * A single energy price point fed into
+ * {@link composeElectricityPrices}.
+ *
+ * Deliberately minimal so any source can be used — spot prices from
+ * `useEpexSpotPrices()`, tariff prices from `useElectricityPrices()`, or a
+ * series fetched from the provider's own API. Use
+ * `fromEnergyPriceEntries()` / `fromEpexSpotEntries()` to adapt the SDK's own
+ * shapes.
+ */
+export interface EnyoComposableEnergyPriceEntry {
+    /** Start of the interval in ISO format. */
+    timestampIso: string;
+    /** Energy price per kWh for this interval, in the composition's currency. */
+    pricePerKwh: number;
+}
+/**
+ * Input for {@link composeElectricityPrices}.
+ */
+export interface EnyoComposeElectricityPricesInput {
+    /**
+     * The energy price series to compose on top of. Entries are matched to the
+     * grid fee and bonus series by `timestampIso`, so all inputs should cover
+     * the same range at 15-minute resolution.
+     */
+    energyPrices: EnyoComposableEnergyPriceEntry[];
+    /**
+     * What the {@link energyPrices} already contain, taken from the tariff's
+     * `priceComposition`. Components flagged as included are reported in the
+     * result but **not added again**. Omitted means "energy price only".
+     */
+    energyPriceComposition?: TariffPriceCompositionInfo;
+    /**
+     * The resolved dynamic grid fee series, e.g. from
+     * `useGridFee().getDynamicGridFees()`. Ignored when the energy prices
+     * already include the grid fee, and may be `null` or omitted when the
+     * tariff has no dynamic grid fee.
+     */
+    gridFees?: EnyoDynamicGridFeeSeries | null;
+    /**
+     * A constant grid fee per kWh, used when the tariff carries one instead of
+     * referencing a dynamic fee. Ignored when {@link gridFees} is given or when
+     * the energy prices already include the grid fee.
+     */
+    constantGridFeePerKwh?: number;
+    /**
+     * The tariff's bonuses. Overlapping bonuses stack additively unless one is
+     * {@link EnyoTariffBonus.exclusive}. Ignored when the energy prices already
+     * have bonuses applied.
+     */
+    bonuses?: EnyoTariffBonus[];
+    /**
+     * Which direction to compose for. Components whose `appliesTo` does not
+     * match are skipped. Defaults to {@link EnyoPriceAppliesToEnum.Consumption}.
+     */
+    appliesTo?: EnyoPriceAppliesToEnum;
+    /**
+     * Optional lower bound for {@link EnyoComposedElectricityPriceEntry.effectivePricePerKwh}.
+     * Left unset by default — effective prices may legitimately go negative,
+     * because wholesale prices do.
+     */
+    minEffectivePricePerKwh?: number;
+    /** Currency code carried through to the result, e.g. `'EUR'`. */
+    currency?: string;
+}
+/**
+ * One fully composed 15-minute price interval, with every component reported
+ * separately so a UI can explain the number and an optimizer can reason about
+ * its parts.
+ */
+export interface EnyoComposedElectricityPriceEntry {
+    /** Start of the interval in ISO format. */
+    timestampIso: string;
+    /**
+     * The price taken from the source series for this interval. When the source
+     * was all-in, it already contains the components whose origin is
+     * `included`.
+     */
+    energyPricePerKwh: number;
+    /**
+     * Grid fee per kWh attributable to this interval; `0` when none applies.
+     *
+     * Reported even when {@link gridFeeOrigin} is
+     * {@link EnyoPriceComponentOriginEnum.Included} — provided a fee series was
+     * passed in — so a UI can break down an all-in price without the composer
+     * adding the amount a second time.
+     */
+    gridFeePerKwh: number;
+    /**
+     * Whether {@link gridFeePerKwh} was added by the composer, was already part
+     * of the energy price, or does not apply.
+     */
+    gridFeeOrigin: EnyoPriceComponentOriginEnum;
+    /** Total discount per kWh applied to this interval; `0` when none applies. */
+    bonusPerKwh: number;
+    /**
+     * Whether {@link bonusPerKwh} was applied by the composer, was already part
+     * of the energy price, or does not apply.
+     */
+    bonusOrigin: EnyoPriceComponentOriginEnum;
+    /** Ids of the bonuses that contributed to {@link bonusPerKwh}. */
+    appliedBonusIds: string[];
+    /**
+     * The final price per kWh for this interval:
+     * `energyPricePerKwh + gridFeePerKwh - bonusPerKwh`, with components whose
+     * origin is `included` already contained in `energyPricePerKwh` and
+     * therefore not counted twice.
+     */
+    effectivePricePerKwh: number;
+    /** Currency of every amount in this entry, when known. */
+    currency?: string;
+}

package/dist/cjs/types/enyo-price-schedule.cjs

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Shared scheduling primitives for time-dependent price components
+ * (dynamic grid fees and tariff bonuses).
+ *
+ * All amounts in this module are expressed **per kilowatt hour** and are always
+ * a positive magnitude — the direction is defined by the component that carries
+ * the schedule: a grid fee is *added* to the energy price, a tariff bonus is
+ * *subtracted* from it. Keeping magnitudes unsigned removes the single most
+ * common integration mistake (an inverted sign silently flipping an optimizer's
+ * decisions) and is enforced by the validators in
+ * `implementations/pricing/price-schedule-validators.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnyoPriceAppliesToEnum = exports.EnyoPriceScheduleTypeEnum = void 0;
+/**
+ * The kind of schedule a price component follows.
+ */
+var EnyoPriceScheduleTypeEnum;
+(function (EnyoPriceScheduleTypeEnum) {
+    /** One amount that applies at every point in time. */
+    EnyoPriceScheduleTypeEnum["Constant"] = "constant";
+    /**
+     * Calendar-recurring windows — used for high-tariff/low-tariff (HT/NT)
+     * network charges, seasonal charges, and weekday-dependent bonuses.
+     */
+    EnyoPriceScheduleTypeEnum["Recurring"] = "recurring";
+    /**
+     * Explicit absolute time windows — used for grid fees or bonuses published
+     * as a dated series (e.g. a day-ahead publication by the grid operator).
+     */
+    EnyoPriceScheduleTypeEnum["Absolute"] = "absolute";
+})(EnyoPriceScheduleTypeEnum || (exports.EnyoPriceScheduleTypeEnum = EnyoPriceScheduleTypeEnum = {}));
+/**
+ * Which energy direction a price component applies to.
+ */
+var EnyoPriceAppliesToEnum;
+(function (EnyoPriceAppliesToEnum) {
+    /** Applies to energy drawn from the grid. */
+    EnyoPriceAppliesToEnum["Consumption"] = "consumption";
+    /** Applies to energy fed into the grid. */
+    EnyoPriceAppliesToEnum["FeedIn"] = "feed-in";
+    /** Applies to both directions. */
+    EnyoPriceAppliesToEnum["Both"] = "both";
+})(EnyoPriceAppliesToEnum || (exports.EnyoPriceAppliesToEnum = EnyoPriceAppliesToEnum = {}));

package/dist/cjs/types/enyo-price-schedule.d.cts

@@ -0,0 +1,137 @@
+/**
+ * Shared scheduling primitives for time-dependent price components
+ * (dynamic grid fees and tariff bonuses).
+ *
+ * All amounts in this module are expressed **per kilowatt hour** and are always
+ * a positive magnitude — the direction is defined by the component that carries
+ * the schedule: a grid fee is *added* to the energy price, a tariff bonus is
+ * *subtracted* from it. Keeping magnitudes unsigned removes the single most
+ * common integration mistake (an inverted sign silently flipping an optimizer's
+ * decisions) and is enforced by the validators in
+ * `implementations/pricing/price-schedule-validators.ts`.
+ */
+/**
+ * The kind of schedule a price component follows.
+ */
+export declare enum EnyoPriceScheduleTypeEnum {
+    /** One amount that applies at every point in time. */
+    Constant = "constant",
+    /**
+     * Calendar-recurring windows — used for high-tariff/low-tariff (HT/NT)
+     * network charges, seasonal charges, and weekday-dependent bonuses.
+     */
+    Recurring = "recurring",
+    /**
+     * Explicit absolute time windows — used for grid fees or bonuses published
+     * as a dated series (e.g. a day-ahead publication by the grid operator).
+     */
+    Absolute = "absolute"
+}
+/**
+ * Which energy direction a price component applies to.
+ */
+export declare enum EnyoPriceAppliesToEnum {
+    /** Applies to energy drawn from the grid. */
+    Consumption = "consumption",
+    /** Applies to energy fed into the grid. */
+    FeedIn = "feed-in",
+    /** Applies to both directions. */
+    Both = "both"
+}
+/**
+ * A calendar-recurring price window.
+ *
+ * Times are wall-clock times in the owning component's `timezone`, so a window
+ * survives daylight-saving transitions: `'22:00'` stays 22:00 local time all
+ * year round.
+ */
+export interface EnyoRecurringPriceWindow {
+    /**
+     * Inclusive start of the window as a local wall-clock time in `HH:mm`
+     * 24-hour notation, e.g. `'22:00'`.
+     */
+    startTimeOfDay: string;
+    /**
+     * Exclusive end of the window as a local wall-clock time in `HH:mm`
+     * notation. May be **earlier** than `startTimeOfDay`, in which case the
+     * window wraps past midnight (e.g. `'22:00'` → `'06:00'`).
+     */
+    endTimeOfDay: string;
+    /**
+     * Days of the week the window applies to, `0` = Sunday … `6` = Saturday.
+     * Omit for "every day".
+     *
+     * For a window that wraps past midnight the day is evaluated against the
+     * day the window **starts** — a Monday 22:00–06:00 window covers Monday
+     * evening and the early hours of Tuesday.
+     */
+    daysOfWeek?: number[];
+    /**
+     * Months the window applies to, `1` = January … `12` = December. Omit for
+     * "every month". Evaluated against the day the window starts, exactly as
+     * {@link daysOfWeek}.
+     */
+    months?: number[];
+    /** Positive amount per kWh that applies inside the window. */
+    amountPerKwh: number;
+}
+/**
+ * An explicit, absolutely-dated price window.
+ */
+export interface EnyoAbsolutePriceWindow {
+    /** Inclusive start of the window in ISO format. */
+    startIso: string;
+    /** Exclusive end of the window in ISO format. */
+    endIso: string;
+    /** Positive amount per kWh that applies inside the window. */
+    amountPerKwh: number;
+}
+/**
+ * A single amount that applies at all times.
+ */
+export interface EnyoConstantPriceSchedule {
+    type: EnyoPriceScheduleTypeEnum.Constant;
+    /** Positive amount per kWh, applied to every interval. */
+    amountPerKwh: number;
+}
+/**
+ * A set of calendar-recurring windows. Intervals not covered by any window
+ * resolve to `0`.
+ */
+export interface EnyoRecurringPriceSchedule {
+    type: EnyoPriceScheduleTypeEnum.Recurring;
+    /** The recurring windows. Must not overlap each other. */
+    windows: EnyoRecurringPriceWindow[];
+}
+/**
+ * A set of absolutely-dated windows. Intervals not covered by any window
+ * resolve to `0`.
+ */
+export interface EnyoAbsolutePriceSchedule {
+    type: EnyoPriceScheduleTypeEnum.Absolute;
+    /** The dated windows. Must not overlap each other. */
+    windows: EnyoAbsolutePriceWindow[];
+}
+/**
+ * Any supported price component schedule, discriminated by `type`.
+ */
+export type EnyoPriceSchedule = EnyoConstantPriceSchedule | EnyoRecurringPriceSchedule | EnyoAbsolutePriceSchedule;
+/**
+ * One resolved 15-minute interval produced by expanding an
+ * {@link EnyoPriceSchedule} over a time range.
+ */
+export interface EnyoResolvedPriceEntry {
+    /** Start of the 15-minute interval in ISO format. */
+    timestampIso: string;
+    /** Resolved positive amount per kWh for this interval; `0` when uncovered. */
+    amountPerKwh: number;
+}
+/**
+ * Restricts a price component query to a time range.
+ */
+export interface EnyoPriceRangeFilter {
+    /** Start of the requested range in ISO format (inclusive). */
+    fromIso: string;
+    /** End of the requested range in ISO format (exclusive). */
+    untilIso: string;
+}

package/dist/cjs/version.cjs

@@ -9,7 +9,7 @@ exports.getSdkVersion = getSdkVersion;
 /**
  * Current version of the enyo Energy App SDK.
  */
-exports.SDK_VERSION = '1.2.0';
+exports.SDK_VERSION = '1.3.0';
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/cjs/version.d.cts

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export declare const SDK_VERSION = "1.2.0";
+export declare const SDK_VERSION = "1.3.0";
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/energy-app-package-definition.d.ts

@@ -16,6 +16,7 @@ export declare enum EnergyAppPackageCategory {
     TemperatureSensor = "temperature-sensor",
     SmartPlug = "smart-plug",
     HeatingRod = "heating-rod",
+    GridOperator = "grid-operator",
     Other = "other"
 }
 /**

package/dist/energy-app-package-definition.js

@@ -14,6 +14,7 @@ export var EnergyAppPackageCategory;
     EnergyAppPackageCategory["TemperatureSensor"] = "temperature-sensor";
     EnergyAppPackageCategory["SmartPlug"] = "smart-plug";
     EnergyAppPackageCategory["HeatingRod"] = "heating-rod";
+    EnergyAppPackageCategory["GridOperator"] = "grid-operator";
     EnergyAppPackageCategory["Other"] = "other";
 })(EnergyAppPackageCategory || (EnergyAppPackageCategory = {}));
 /**

package/dist/energy-app-permission.type.d.ts

@@ -55,7 +55,9 @@ export declare enum EnergyAppPermissionTypeEnum {
     Automation = "Automation",
     Savings = "Savings",
     EpexSpotPrices = "EpexSpotPrices",
-    FirmwareRegistry = "FirmwareRegistry"
+    FirmwareRegistry = "FirmwareRegistry",
+    GridFeeRegister = "GridFeeRegister",
+    GridFeeUse = "GridFeeUse"
 }
 /**
  * String union of every permission name, derived from

package/dist/energy-app-permission.type.js

@@ -57,4 +57,6 @@ export var EnergyAppPermissionTypeEnum;
     EnergyAppPermissionTypeEnum["Savings"] = "Savings";
     EnergyAppPermissionTypeEnum["EpexSpotPrices"] = "EpexSpotPrices";
     EnergyAppPermissionTypeEnum["FirmwareRegistry"] = "FirmwareRegistry";
+    EnergyAppPermissionTypeEnum["GridFeeRegister"] = "GridFeeRegister";
+    EnergyAppPermissionTypeEnum["GridFeeUse"] = "GridFeeUse";
 })(EnergyAppPermissionTypeEnum || (EnergyAppPermissionTypeEnum = {}));

package/dist/energy-app.d.ts

@@ -45,6 +45,7 @@ import { EnergyAppAutomation } from "./packages/energy-app-automation.js";
 import { EnergyAppSavings } from "./packages/energy-app-savings.js";
 import { EnergyAppDeviceTest } from "./packages/energy-app-device-test.js";
 import { EnergyAppEpexSpotPrice } from "./packages/energy-app-epex-spot-price.js";
+import { EnergyAppGridFee } from "./packages/energy-app-grid-fee.js";
 import { UseFetchOptions } from "./types/enyo-fetch.js";
 /**
  * Concrete implementation of {@link EnyoEnergyAppSdk} that delegates every call
@@ -366,6 +367,20 @@ export declare class EnergyApp implements EnyoEnergyAppSdk {
      *         permission is not granted.
      */
     useEpexSpotPrices(): EnergyAppEpexSpotPrice;
+    /**
+     * Gets the Grid Fee API for publishing time-dependent grid fees (network
+     * charges) and resolving them to a 15-minute series.
+     *
+     * Nothing published here is folded into a price automatically — provider
+     * APIs differ in whether their prices already contain the network charge, so
+     * the app that owns the tariff declares that via the tariff's
+     * `priceComposition` and composes the effective price itself with
+     * `composeElectricityPrices()`.
+     * @returns The Grid Fee API instance
+     * @throws {EnergyAppPermissionNotGrantedError} If the `GridFeeRegister` or
+     *         `GridFeeUse` permission required by the called method is not granted.
+     */
+    useGridFee(): EnergyAppGridFee;
     /**
      * Gets the current SDK version.
      * @returns The semantic version string of the SDK

package/dist/energy-app.js

@@ -440,6 +440,22 @@ export class EnergyApp {
     useEpexSpotPrices() {
         return this.energyAppSdk.useEpexSpotPrices();
     }
+    /**
+     * Gets the Grid Fee API for publishing time-dependent grid fees (network
+     * charges) and resolving them to a 15-minute series.
+     *
+     * Nothing published here is folded into a price automatically — provider
+     * APIs differ in whether their prices already contain the network charge, so
+     * the app that owns the tariff declares that via the tariff's
+     * `priceComposition` and composes the effective price itself with
+     * `composeElectricityPrices()`.
+     * @returns The Grid Fee API instance
+     * @throws {EnergyAppPermissionNotGrantedError} If the `GridFeeRegister` or
+     *         `GridFeeUse` permission required by the called method is not granted.
+     */
+    useGridFee() {
+        return this.energyAppSdk.useGridFee();
+    }
     /**
      * Gets the current SDK version.
      * @returns The semantic version string of the SDK

package/dist/enyo-energy-app-sdk.d.ts

@@ -44,6 +44,7 @@ import { EnergyAppAutomation } from "./packages/energy-app-automation.js";
 import { EnergyAppSavings } from "./packages/energy-app-savings.js";
 import { EnergyAppDeviceTest } from "./packages/energy-app-device-test.js";
 import { EnergyAppEpexSpotPrice } from "./packages/energy-app-epex-spot-price.js";
+import { EnergyAppGridFee } from "./packages/energy-app-grid-fee.js";
 import { UseFetchOptions } from "./types/enyo-fetch.js";
 export declare enum EnergyAppStateEnum {
     Launching = "launching",
@@ -163,4 +164,6 @@ export interface EnyoEnergyAppSdk {
     useDeviceTest: () => EnergyAppDeviceTest;
     /** Get the EPEX SPOT Price API for reading the cleared day-ahead wholesale electricity prices that apply to this device */
     useEpexSpotPrices: () => EnergyAppEpexSpotPrice;
+    /** Get the Grid Fee API for publishing time-dependent network charges and resolving them to a 15-minute series */
+    useGridFee: () => EnergyAppGridFee;
 }