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

package/README.md

@@ -1232,38 +1232,70 @@ Three things to get right:
 
 #### `useElectricityTariff(): EnergyAppElectricityTariff`
 
-Register, retrieve, and manage electricity tariffs. One tariff can be marked as the system default.
+A site has **two tariff slots** — one for consumption, one for feed-in — and every method addresses
+them by `EnyoTariffDirectionEnum`. There is no tariff list, no default flag and no tariff id:
+occupying a slot is what it means to be the tariff in force.
+
+Consumers read:
 
 ```typescript
 const tariffs = energyApp.useElectricityTariff();
 
-await tariffs.registerTariff({
-    tariffType: ElectricityTariffTypeEnum.Dynamic,
-    tariffName: 'Spot 2026',
-    vendorName: 'enyo',
-    dynamicTariffData: { currency: 'EUR', gridFeePerKwh: 0.0912 },
+const tariff = await tariffs.getTariff(EnyoTariffDirectionEnum.Consumption);
+const prices = await tariffs.getPrices(EnyoTariffDirectionEnum.Consumption, { fromIso, untilIso });
+
+// Never add a component the series already contains.
+const needsGridFee = !prices?.includes.includes(EnyoPriceComponentEnum.GridFee);
+```
+
+The app that integrates a provider owns the other side. It answers when the user picks it, sets the
+tariff once it is actually usable, and pushes prices as they arrive:
+
+```typescript
+tariffs.onTariffSelected(async direction => {
+    if (!await isAuthenticated()) {
+        return {
+            status: EnyoTariffActivationStatusEnum.AuthenticationRequired,
+            authenticationUrl: buildOAuthUrl(direction),
+        };
+    }
+    await tariffs.setTariff(direction, {
+        name: 'Spot 2026',
+        vendorName: 'enyo',
+        currency: EnyoCurrencyEnum.EUR,
+        pricing: { type: EnyoTariffPricingTypeEnum.Dynamic },
+        externalTariffId: contract.id,
+    });
+    return { status: EnyoTariffActivationStatusEnum.Success };
 });
-await tariffs.makeDefaultTariff('t1');
 
-const defaultTariff = await tariffs.getDefaultTariff();
-const all = await tariffs.getAllTariffs();
+await tariffs.publishPrices(EnyoTariffDirectionEnum.Consumption, {
+    includes: [EnyoPriceComponentEnum.GridFee],   // ← we folded the fee in ourselves
+    entries,
+});
 ```
 
-A tariff can also declare that its grid fee is **dynamic**, state what its prices already include, and
-carry any number of **bonuses** — see [Dynamic Grid Fees & Tariff Bonuses](#dynamic-grid-fees--tariff-bonuses).
+**Calling `setTariff` is the activation signal.** Return `AuthenticationRequired` or
+`OnboardingRequired` from the handler to have the host send the user somewhere, and carry the
+`authenticationUrl` / `onboardingGuideId` that makes it actionable; when that flow later completes,
+call `setTariff` and the slot goes live. There is nothing else to report.
 
-Register a listener to be told when any tariff changes — a new default, a changed grid fee link, an
-added or expired bonus all invalidate a previously composed price series:
+Prices are **pushed, not pulled** — providers publish day-ahead prices on their own schedule and
+rate-limit their APIs, so an app fetches when it makes sense and publishes what it got.
+
+Listen for slot changes to know when to recompose:
 
 ```typescript
-const listenerId = tariffs.onTariffChanged(async event => {
-    if (event.changeType === EnyoTariffChangeTypeEnum.Removed) return;
+const unsubscribe = tariffs.onTariffChanged(async event => {
+    if (event.direction !== EnyoTariffDirectionEnum.Consumption) return;
     await recomposePrices(event.tariff);
 });
 // later
-tariffs.offTariffChanged(listenerId);
+unsubscribe();
 ```
 
+A tariff carries **no grid fee** — see [Dynamic Grid Fees & Tariff Bonuses](#dynamic-grid-fees--tariff-bonuses).
+
 Requires the `ElectricityTariff` permission.
 
 #### `useGridFee(): EnergyAppGridFee`
@@ -1273,7 +1305,7 @@ Publish time-dependent grid fees (network charges) and resolve them to a 15-minu
 
 ```typescript
 const gridFee = energyApp.useGridFee();
-const fees = await gridFee.getDynamicGridFees({ fromIso, untilIso });
+const fees = await gridFee.getGridFeeValues({ fromIso, untilIso });
 ```
 
 Publishers need `GridFeeRegister`; consumers need `GridFeeUse`.
@@ -2986,19 +3018,19 @@ period.
 
 That is not a stylistic choice. Provider APIs disagree with each other: some already return
 grid-fee-inclusive prices, others return the bare energy price. Only the app that owns the tariff
-knows which — so it *declares* it on the tariff, and composes accordingly. A host that silently added
-network charges would double-count for half the providers on the market.
+knows which — so it *declares* it on the price series it publishes, and composes accordingly. A host
+that silently added network charges would double-count for half the providers on the market.
 
 ```typescript
-const tariff = await energyApp.useElectricityTariff().getDefaultTariff();
-const fees   = await energyApp.useGridFee().getDynamicGridFees({ fromIso, untilIso });
+const series = await energyApp.useElectricityTariff().getPrices(direction, { fromIso, untilIso });
+const fees   = await energyApp.useGridFee().getGridFeeValues({ fromIso, untilIso });
 const spot   = await energyApp.useEpexSpotPrices().getPrices({ fromIso, untilIso });
 
 const prices = composeElectricityPrices({
     energyPrices: fromEpexSpotEntries(spot.entries),
-    energyPriceComposition: tariff?.priceComposition,  // ← what the prices already contain
-    gridFees: fees,
-    bonuses: tariff?.bonuses,
+    energyPriceComposition: series?.includes,   // ← what the prices already contain
+    gridFees: fromGridFeeEntries(fees),         // ← gross cent → currency units
+    bonuses: myBonuses,
     currency: 'EUR',
 });
 
@@ -3035,50 +3067,48 @@ Three schedule types cover what grid operators and suppliers actually publish:
 |---|---|
 | `Constant` | one amount that never changes |
 | `Recurring` | HT/NT, weekday-dependent and seasonal windows (`daysOfWeek`, `months`) |
-| `Absolute` | dated series, e.g. a day-ahead publication — republish with `publishGridFeeWindows()` |
+| `Absolute` | dated series, e.g. a day-ahead publication — republish with `registerGridFee()` |
 
 A `Recurring` window may wrap past midnight (`22:00` → `06:00`). When it does, `daysOfWeek` and
 `months` are evaluated against the day the window **starts** — a Monday-only 22:00–06:00 window covers
 Monday evening *and* the early hours of Tuesday.
 
-### Declaring it on a tariff
+### Declaring it on a price series
+
+A tariff carries **no grid fee at all**. It is neither a field on the tariff nor something the tariff
+declares a mode for: a network charge belongs to the site's grid connection, is registered
+independently with `useGridFee()`, and stays the same whichever supplier the site buys from. That is
+why `getGridFee()` takes no arguments and `getGridFeeValues()` takes no tariff selector.
+
+What the owning app *does* declare is what its published prices already contain:
 
 ```typescript
-await energyApp.useElectricityTariff().registerTariff({
-    tariffType: ElectricityTariffTypeEnum.Dynamic,
-    tariffName: 'Spot 2026',
-    vendorName: 'enyo',
-    priceComposition: { includesGridFee: false },   // provider returns the bare energy price
-    dynamicTariffData: {
-        currency: 'EUR',
-        gridFeeMode: GridFeeModeEnum.Dynamic,       // read the fee from useGridFee(), don't carry one
-    },
-    bonuses: [{
-        id: 'night',
-        name: 'Nachtbonus',
-        timezone: 'Europe/Berlin',
-        appliesTo: EnyoPriceAppliesToEnum.Consumption,
-        schedule: {
-            type: EnyoPriceScheduleTypeEnum.Recurring,
-            windows: [{ startTimeOfDay: '22:00', endTimeOfDay: '06:00', amountPerKwh: 0.05 }],
-        },
-    }],
+await energyApp.useElectricityTariff().publishPrices(EnyoTariffDirectionEnum.Consumption, {
+    includes: [],   // the bare energy price — the consumer adds the grid fee
+    entries,
 });
 ```
 
-The tariff declares only *that* its grid fee is time-dependent, never *which* fee applies. **A grid fee
-is not bound to a tariff** — it belongs to the site's grid connection, is registered independently, and
-stays the same whichever supplier the site buys from. That is why `getDynamicGridFees()` takes no
-tariff selector.
+If the provider ships all-in prices instead, publish `includes: [EnyoPriceComponentEnum.GridFee]` and
+consumers will report the fee without adding it a second time. Declaring an included component you did
+not actually apply is the one mistake that silently under-prices every interval.
 
-`gridFeeMode` defaults to `Static`, so tariffs written before this existed keep working unchanged, and
-`DynamicTariffData.gridFeePerKwh` remains the constant fallback (now deprecated). The declaration is
-available on **all three** tariff shapes — a fixed energy price with time-variable network charges is a
-real product.
+Bonuses work the same way — either apply them yourself and declare
+`EnyoPriceComponentEnum.Bonuses`, or hand them to `composeElectricityPrices()` and have them applied
+and reported separately:
 
-If the provider ships all-in prices instead, set `priceComposition.includesGridFee: true` and leave
-`gridFeeMode` alone. Combining it with `Dynamic` is rejected by `validateElectricityTariffPricing()` —
-it is the exact configuration that double-counts.
+```typescript
+const bonuses = [{
+    id: 'night',
+    name: 'Nachtbonus',
+    timezone: 'Europe/Berlin',
+    appliesTo: EnyoPriceAppliesToEnum.Consumption,
+    schedule: {
+        type: EnyoPriceScheduleTypeEnum.Recurring,
+        windows: [{ startTimeOfDay: '22:00', endTimeOfDay: '06:00', amountPerKwh: 0.05 }],
+    },
+}];
+```
 
 ### Multiple bonuses, and how they stack
 
@@ -3133,7 +3163,7 @@ energyApp.useElectricityTariff().onTariffChanged(() => recompose()); // new defa
 | `fromEnergyPriceEntries()` / `fromEpexSpotEntries()` | adapt the SDK's price shapes into composer input |
 | `resolveTariffBonuses()` | resolve a tariff's bonuses to 15-min intervals, stacking rule applied |
 | `resolvePriceSchedule()` | expand any schedule to a 15-min series (DST-aware, dependency-free) |
-| `validateDynamicGridFee()` / `validateElectricityTariffPricing()` | catch overlapping windows, negative amounts and double-count configurations before registering |
+| `validateDynamicGridFee()` / `validateTariffBonuses()` | catch overlapping windows and negative amounts before registering |
 
 ### Not covered
 

package/dist/cjs/energy-app.cjs

@@ -444,14 +444,20 @@ class EnergyApp {
         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.
+     * Gets the Grid Fee API for publishing grid fees (network charges), asking
+     * which one applies, and resolving it to a 15-minute series.
+     *
+     * This is the single source for grid fees. A network charge belongs to the
+     * site's grid connection rather than to a supplier contract, so a tariff
+     * carries no fee of its own and declares nothing about how one is
+     * determined — constant and time-dependent fees are both registered and read
+     * here.
      *
      * 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()`.
+     * APIs differ in whether their prices already contain the network charge.
+     * The app that owns the tariff declares that one fact via the tariff's
+     * the price series' `includes` 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.

package/dist/cjs/energy-app.d.cts

@@ -368,14 +368,20 @@ export declare class EnergyApp implements EnyoEnergyAppSdk {
      */
     useEpexSpotPrices(): EnergyAppEpexSpotPrice;
     /**
-     * Gets the Grid Fee API for publishing time-dependent grid fees (network
-     * charges) and resolving them to a 15-minute series.
+     * Gets the Grid Fee API for publishing grid fees (network charges), asking
+     * which one applies, and resolving it to a 15-minute series.
+     *
+     * This is the single source for grid fees. A network charge belongs to the
+     * site's grid connection rather than to a supplier contract, so a tariff
+     * carries no fee of its own and declares nothing about how one is
+     * determined — constant and time-dependent fees are both registered and read
+     * here.
      *
      * 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()`.
+     * APIs differ in whether their prices already contain the network charge.
+     * The app that owns the tariff declares that one fact via the tariff's
+     * the price series' `includes` 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.

package/dist/cjs/implementations/appliances/appliance-manager.cjs

@@ -290,12 +290,18 @@ class ApplianceManager {
         const updatedListenerId = applianceService.listenForApplianceUpdated((appliance) => {
             if (this.disposed)
                 return;
+            if (this.config.enableLogging) {
+                console.debug(`Appliance updated event for ${appliance.id}`);
+            }
             this.updateCache(appliance);
         });
         this.listenerIds.push(updatedListenerId);
         const removedListenerId = applianceService.listenForApplianceRemoved((applianceId) => {
             if (this.disposed)
                 return;
+            if (this.config.enableLogging) {
+                console.debug(`Appliance removed event for ${applianceId}`);
+            }
             this.removeFromCache(applianceId);
         });
         this.listenerIds.push(removedListenerId);

package/dist/cjs/implementations/pricing/compose-electricity-prices.cjs

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromEnergyPriceEntries = fromEnergyPriceEntries;
+exports.fromGridFeeEntries = fromGridFeeEntries;
 exports.fromEpexSpotEntries = fromEpexSpotEntries;
 exports.resolveTariffBonuses = resolveTariffBonuses;
 exports.composeElectricityPrices = composeElectricityPrices;
+const enyo_electricity_tariff_js_1 = require("../../types/enyo-electricity-tariff.cjs");
 const enyo_price_composition_js_1 = require("../../types/enyo-price-composition.cjs");
 const enyo_price_schedule_js_1 = require("../../types/enyo-price-schedule.cjs");
 const price_schedule_resolver_js_1 = require("./price-schedule-resolver.cjs");
@@ -27,12 +29,43 @@ function fromEnergyPriceEntries(entries, direction = enyo_price_schedule_js_1.En
         pricePerKwh: entry.consumptionPricePerKwh,
     }));
 }
+/**
+ * Converts a grid fee series from `useGridFee().getGridFeeValues()` into the
+ * unit the composer works in.
+ *
+ * This is the **only** place cent meets currency in the pricing path, and it
+ * exists so the conversion happens once, visibly, instead of at every call site.
+ * Grid fees are published and read as gross **cent** per kWh because that is how
+ * they are quoted and configured; energy prices are in whole currency units
+ * (EUR/kWh), so a fee added to a price without dividing by 100 overstates it by
+ * a factor of 100 — a mistake that survives review because both numbers look
+ * plausible.
+ *
+ * Pass the result as {@link EnyoComposeElectricityPricesInput.gridFees}. Whether
+ * the amounts include the fee's additional charges is decided when the series is
+ * fetched, not here.
+ *
+ * @param series - The series returned by `getGridFeeValues()`, or `null`
+ * @returns The same series with amounts in currency per kWh, or `null` when the input was
+ */
+function fromGridFeeEntries(series) {
+    if (series == null) {
+        return null;
+    }
+    return {
+        appliesTo: series.appliesTo,
+        entries: series.entries.map(entry => ({
+            timestampIso: entry.timestampIso,
+            feePerKwh: entry.grossCentPerKwh / 100,
+        })),
+    };
+}
 /**
  * Adapts an EPEX SPOT day-ahead series into composer input.
  *
  * Spot prices are the raw exchange result and contain neither grid fees nor
- * levies, taxes or supplier margin — so the tariff's `priceComposition` for such
- * a series should leave every `includes*` flag `false`.
+ * levies, taxes or supplier margin — so a series built from them should declare
+ * no included components at all.
  *
  * @param entries - Spot price entries as returned by the EPEX SPOT price API
  * @returns Composable energy price entries
@@ -120,12 +153,16 @@ function gridFeeByTimestamp(series) {
 }
 /**
  * Composes the effective electricity price per 15-minute interval from an energy
- * price series, a dynamic grid fee and a tariff's bonuses.
+ * price series, a grid fee and a tariff's bonuses.
+ *
+ * The three inputs come from three independent sources and are deliberately not
+ * coupled: energy prices from the tariff or the spot market, the grid fee from
+ * `useGridFee()`, the bonuses from the tariff. Pass whichever apply.
  *
  * This runs **in the energy app**, never in the host, because only the app knows
  * what its provider's API already returns: some providers deliver all-in prices
  * with the network charge baked in, others deliver the pure energy price. Pass
- * the tariff's `priceComposition` as `energyPriceComposition` and the composer
+ * the price series' `includes` as `energyPriceComposition` and the composer
  * reports each component without adding one that is already included.
  *
  * Every component is reported separately — `gridFeePerKwh` with its
@@ -142,15 +179,15 @@ function gridFeeByTimestamp(series) {
  *
  * @example
  * ```typescript
- * const tariff = await energyApp.useElectricityTariff().getDefaultTariff();
- * const fees = await energyApp.useGridFee().getDynamicGridFees({fromIso, untilIso});
+ * const series = await energyApp.useElectricityTariff().getPrices(direction, {fromIso, untilIso});
+ * const fees = await energyApp.useGridFee().getGridFeeValues({fromIso, untilIso});
  * const spot = await energyApp.useEpexSpotPrices().getPrices({fromIso, untilIso});
  *
  * const prices = composeElectricityPrices({
  *     energyPrices: fromEpexSpotEntries(spot.entries),
- *     energyPriceComposition: tariff?.priceComposition,
+ *     energyPriceComposition: series?.includes,
  *     gridFees: fees,
- *     bonuses: tariff?.bonuses,
+ *     bonuses: myBonuses,
  *     currency: 'EUR',
  * });
  *
@@ -159,8 +196,8 @@ function gridFeeByTimestamp(series) {
  */
 function composeElectricityPrices(input) {
     const direction = input.appliesTo ?? enyo_price_schedule_js_1.EnyoPriceAppliesToEnum.Consumption;
-    const gridFeeIncluded = input.energyPriceComposition?.includesGridFee === true;
-    const bonusesIncluded = input.energyPriceComposition?.includesBonuses === true;
+    const gridFeeIncluded = input.energyPriceComposition?.includes(enyo_electricity_tariff_js_1.EnyoPriceComponentEnum.GridFee) === true;
+    const bonusesIncluded = input.energyPriceComposition?.includes(enyo_electricity_tariff_js_1.EnyoPriceComponentEnum.Bonuses) === true;
     const gridFeeSeriesApplies = input.gridFees != null && appliesToDirection(input.gridFees.appliesTo, direction);
     const resolvedGridFees = gridFeeSeriesApplies ? gridFeeByTimestamp(input.gridFees) : new Map();
     const constantGridFee = !gridFeeSeriesApplies && input.constantGridFeePerKwh !== undefined ? input.constantGridFeePerKwh : undefined;

package/dist/cjs/implementations/pricing/compose-electricity-prices.d.cts

@@ -1,7 +1,8 @@
 import { EnyoTariffBonus } from '../../types/enyo-electricity-tariff.cjs';
 import { EnyoEnergyPriceEntry } from '../../types/enyo-energy-prices.cjs';
 import { EnyoEpexSpotPriceEntry } from '../../types/enyo-epex-spot-price.cjs';
-import { EnyoComposableEnergyPriceEntry, EnyoComposeElectricityPricesInput, EnyoComposedElectricityPriceEntry } from '../../types/enyo-price-composition.cjs';
+import { EnyoGridFeeSeries } from '../../types/enyo-grid-fee.cjs';
+import { EnyoComposableEnergyPriceEntry, EnyoComposableGridFeeSeries, EnyoComposeElectricityPricesInput, EnyoComposedElectricityPriceEntry } from '../../types/enyo-price-composition.cjs';
 import { EnyoPriceAppliesToEnum } from '../../types/enyo-price-schedule.cjs';
 /**
  * Adapts a tariff price series from `useElectricityPrices().getPrices()` into
@@ -13,12 +14,32 @@ import { EnyoPriceAppliesToEnum } from '../../types/enyo-price-schedule.cjs';
  * @returns Composable energy price entries
  */
 export declare function fromEnergyPriceEntries(entries: EnyoEnergyPriceEntry[], direction?: EnyoPriceAppliesToEnum): EnyoComposableEnergyPriceEntry[];
+/**
+ * Converts a grid fee series from `useGridFee().getGridFeeValues()` into the
+ * unit the composer works in.
+ *
+ * This is the **only** place cent meets currency in the pricing path, and it
+ * exists so the conversion happens once, visibly, instead of at every call site.
+ * Grid fees are published and read as gross **cent** per kWh because that is how
+ * they are quoted and configured; energy prices are in whole currency units
+ * (EUR/kWh), so a fee added to a price without dividing by 100 overstates it by
+ * a factor of 100 — a mistake that survives review because both numbers look
+ * plausible.
+ *
+ * Pass the result as {@link EnyoComposeElectricityPricesInput.gridFees}. Whether
+ * the amounts include the fee's additional charges is decided when the series is
+ * fetched, not here.
+ *
+ * @param series - The series returned by `getGridFeeValues()`, or `null`
+ * @returns The same series with amounts in currency per kWh, or `null` when the input was
+ */
+export declare function fromGridFeeEntries(series: EnyoGridFeeSeries | null | undefined): EnyoComposableGridFeeSeries | null;
 /**
  * Adapts an EPEX SPOT day-ahead series into composer input.
  *
  * Spot prices are the raw exchange result and contain neither grid fees nor
- * levies, taxes or supplier margin — so the tariff's `priceComposition` for such
- * a series should leave every `includes*` flag `false`.
+ * levies, taxes or supplier margin — so a series built from them should declare
+ * no included components at all.
  *
  * @param entries - Spot price entries as returned by the EPEX SPOT price API
  * @returns Composable energy price entries
@@ -60,12 +81,16 @@ export declare function resolveTariffBonuses(bonuses: EnyoTariffBonus[], options
 }>;
 /**
  * Composes the effective electricity price per 15-minute interval from an energy
- * price series, a dynamic grid fee and a tariff's bonuses.
+ * price series, a grid fee and a tariff's bonuses.
+ *
+ * The three inputs come from three independent sources and are deliberately not
+ * coupled: energy prices from the tariff or the spot market, the grid fee from
+ * `useGridFee()`, the bonuses from the tariff. Pass whichever apply.
  *
  * This runs **in the energy app**, never in the host, because only the app knows
  * what its provider's API already returns: some providers deliver all-in prices
  * with the network charge baked in, others deliver the pure energy price. Pass
- * the tariff's `priceComposition` as `energyPriceComposition` and the composer
+ * the price series' `includes` as `energyPriceComposition` and the composer
  * reports each component without adding one that is already included.
  *
  * Every component is reported separately — `gridFeePerKwh` with its
@@ -82,15 +107,15 @@ export declare function resolveTariffBonuses(bonuses: EnyoTariffBonus[], options
  *
  * @example
  * ```typescript
- * const tariff = await energyApp.useElectricityTariff().getDefaultTariff();
- * const fees = await energyApp.useGridFee().getDynamicGridFees({fromIso, untilIso});
+ * const series = await energyApp.useElectricityTariff().getPrices(direction, {fromIso, untilIso});
+ * const fees = await energyApp.useGridFee().getGridFeeValues({fromIso, untilIso});
  * const spot = await energyApp.useEpexSpotPrices().getPrices({fromIso, untilIso});
  *
  * const prices = composeElectricityPrices({
  *     energyPrices: fromEpexSpotEntries(spot.entries),
- *     energyPriceComposition: tariff?.priceComposition,
+ *     energyPriceComposition: series?.includes,
  *     gridFees: fees,
- *     bonuses: tariff?.bonuses,
+ *     bonuses: myBonuses,
  *     currency: 'EUR',
  * });
  *

package/dist/cjs/implementations/pricing/price-component-validators.cjs

@@ -5,9 +5,6 @@ exports.validatePriceSchedule = validatePriceSchedule;
 exports.validateDynamicGridFee = validateDynamicGridFee;
 exports.validateTariffBonus = validateTariffBonus;
 exports.validateTariffBonuses = validateTariffBonuses;
-exports.validateTariffGridFeeConfig = validateTariffGridFeeConfig;
-exports.validateElectricityTariffPricing = validateElectricityTariffPricing;
-const enyo_electricity_tariff_js_1 = require("../../types/enyo-electricity-tariff.cjs");
 const enyo_price_schedule_js_1 = require("../../types/enyo-price-schedule.cjs");
 const price_schedule_resolver_js_1 = require("./price-schedule-resolver.cjs");
 /**
@@ -196,7 +193,6 @@ function validatePriceSchedule(schedule, label = 'schedule') {
  * ```
  */
 function validateDynamicGridFee(registration) {
-    requireNonEmpty(registration.id, 'gridFee.id');
     requireNonEmpty(registration.name, 'gridFee.name');
     requireNonEmpty(registration.gridOperator, 'gridFee.gridOperator');
     requireNonEmpty(registration.currency, 'gridFee.currency');
@@ -240,56 +236,3 @@ function validateTariffBonuses(bonuses) {
         seen.add(bonus.id);
     });
 }
-/**
- * Validates how a tariff's pricing data declares its grid fee.
- *
- * Catches the configuration that silently double-charges the customer: declaring
- * a dynamic grid fee while also declaring that the tariff's prices already
- * include the grid fee. Anyone trusting the declaration would add the fee on top
- * of prices that already contain it.
- *
- * @param config - The grid fee configuration of one tariff pricing shape
- * @param priceComposition - The tariff's price composition declaration, if any
- * @param label - Prefix used in error messages, e.g. `'dynamicTariffData'`
- * @throws {PriceComponentValidationError} On the first invariant violation
- */
-function validateTariffGridFeeConfig(config, priceComposition, label = 'tariffData') {
-    const mode = config.gridFeeMode ?? enyo_electricity_tariff_js_1.GridFeeModeEnum.Static;
-    if (!Object.values(enyo_electricity_tariff_js_1.GridFeeModeEnum).includes(mode)) {
-        fail(`${label}.gridFeeMode must be one of ${Object.values(enyo_electricity_tariff_js_1.GridFeeModeEnum).join(', ')}`);
-    }
-    if (mode === enyo_electricity_tariff_js_1.GridFeeModeEnum.Dynamic && priceComposition?.includesGridFee === true) {
-        fail(`${label} declares a dynamic grid fee while priceComposition.includesGridFee is true — ` +
-            `the fee is already contained in the tariff's prices and must not be added again`);
-    }
-}
-/**
- * Validates the pricing-related parts of a complete electricity tariff: the grid
- * fee link of whichever pricing shape is present, and the tariff's bonuses.
- *
- * Call it before {@link EnergyAppElectricityTariff.registerTariff} to turn what
- * would otherwise be a silently mispriced tariff into an actionable error.
- *
- * @param tariff - The tariff to validate (with or without its `id`)
- * @throws {PriceComponentValidationError} On the first invariant violation
- *
- * @example
- * ```typescript
- * validateElectricityTariffPricing(tariff);
- * await energyApp.useElectricityTariff().registerTariff(tariff);
- * ```
- */
-function validateElectricityTariffPricing(tariff) {
-    if (tariff.staticTariffData !== undefined) {
-        validateTariffGridFeeConfig(tariff.staticTariffData, tariff.priceComposition, 'staticTariffData');
-    }
-    if (tariff.timeVariableTariffData !== undefined) {
-        validateTariffGridFeeConfig(tariff.timeVariableTariffData, tariff.priceComposition, 'timeVariableTariffData');
-    }
-    if (tariff.dynamicTariffData !== undefined) {
-        validateTariffGridFeeConfig(tariff.dynamicTariffData, tariff.priceComposition, 'dynamicTariffData');
-    }
-    if (tariff.bonuses !== undefined) {
-        validateTariffBonuses(tariff.bonuses);
-    }
-}

package/dist/cjs/implementations/pricing/price-component-validators.d.cts

@@ -1,4 +1,4 @@
-import { EnyoElectricityTariff, EnyoTariffBonus, TariffGridFeeConfig, TariffPriceCompositionInfo } from '../../types/enyo-electricity-tariff.cjs';
+import { EnyoTariffBonus } from '../../types/enyo-electricity-tariff.cjs';
 import { EnyoDynamicGridFeeRegistration } from '../../types/enyo-grid-fee.cjs';
 import { EnyoPriceSchedule } from '../../types/enyo-price-schedule.cjs';
 /**
@@ -55,36 +55,3 @@ export declare function validateTariffBonus(bonus: EnyoTariffBonus, label?: stri
  * @throws {PriceComponentValidationError} On the first invariant violation
  */
 export declare function validateTariffBonuses(bonuses: EnyoTariffBonus[]): void;
-/**
- * Validates how a tariff's pricing data declares its grid fee.
- *
- * Catches the configuration that silently double-charges the customer: declaring
- * a dynamic grid fee while also declaring that the tariff's prices already
- * include the grid fee. Anyone trusting the declaration would add the fee on top
- * of prices that already contain it.
- *
- * @param config - The grid fee configuration of one tariff pricing shape
- * @param priceComposition - The tariff's price composition declaration, if any
- * @param label - Prefix used in error messages, e.g. `'dynamicTariffData'`
- * @throws {PriceComponentValidationError} On the first invariant violation
- */
-export declare function validateTariffGridFeeConfig(config: TariffGridFeeConfig, priceComposition: TariffPriceCompositionInfo | undefined, label?: string): void;
-/**
- * Validates the pricing-related parts of a complete electricity tariff: the grid
- * fee link of whichever pricing shape is present, and the tariff's bonuses.
- *
- * Call it before {@link EnergyAppElectricityTariff.registerTariff} to turn what
- * would otherwise be a silently mispriced tariff into an actionable error.
- *
- * @param tariff - The tariff to validate (with or without its `id`)
- * @throws {PriceComponentValidationError} On the first invariant violation
- *
- * @example
- * ```typescript
- * validateElectricityTariffPricing(tariff);
- * await energyApp.useElectricityTariff().registerTariff(tariff);
- * ```
- */
-export declare function validateElectricityTariffPricing(tariff: Omit<EnyoElectricityTariff, 'id'> & {
-    id?: string;
-}): void;