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

package/dist/cjs/implementations/pricing/price-schedule-resolver.d.cts

@@ -0,0 +1,95 @@
+import { EnyoPriceSchedule, EnyoResolvedPriceEntry } from '../../types/enyo-price-schedule.cjs';
+/**
+ * Length of one resolved interval, in minutes. Matches the resolution of
+ * `useElectricityPrices().getPrices()` so resolved schedules can be combined
+ * with a price series interval by interval.
+ */
+export declare const PRICE_SCHEDULE_INTERVAL_MINUTES = 15;
+/**
+ * Wall-clock calendar fields of an instant, as seen in a specific time zone.
+ */
+export interface ZonedDateParts {
+    /** Full year, e.g. `2026`. */
+    year: number;
+    /** Month, `1` = January … `12` = December. */
+    month: number;
+    /** Day of the month, starting at `1`. */
+    day: number;
+    /** Day of the week, `0` = Sunday … `6` = Saturday. */
+    weekday: number;
+    /** Hour in 24-hour notation, `0`–`23`. */
+    hour: number;
+    /** Minute, `0`–`59`. */
+    minute: number;
+    /** Minutes since local midnight (`hour * 60 + minute`). */
+    minutesOfDay: number;
+}
+/**
+ * Projects an instant onto the wall clock of a time zone.
+ *
+ * Uses `Intl.DateTimeFormat`, so daylight-saving transitions are handled by the
+ * platform's time zone database without pulling in a dependency.
+ *
+ * @param date - The instant to project
+ * @param timezone - IANA time zone identifier, e.g. `'Europe/Berlin'`
+ * @returns The wall-clock calendar fields of `date` in `timezone`
+ * @throws {RangeError} If `timezone` is not a valid IANA identifier
+ */
+export declare function getZonedDateParts(date: Date, timezone: string): ZonedDateParts;
+/**
+ * Parses an `HH:mm` wall-clock time into minutes since midnight.
+ *
+ * @param value - Time in 24-hour `HH:mm` notation, e.g. `'22:00'`
+ * @returns Minutes since midnight, or `null` when the value is malformed
+ */
+export declare function parseTimeOfDay(value: string): number | null;
+/**
+ * Rounds an instant down to the start of its 15-minute interval.
+ *
+ * @param timestampMs - Epoch milliseconds
+ * @returns Epoch milliseconds of the interval start
+ */
+export declare function floorToInterval(timestampMs: number): number;
+/**
+ * Options for {@link resolvePriceSchedule}.
+ */
+export interface ResolvePriceScheduleOptions {
+    /** Start of the range to resolve, in ISO format (inclusive). */
+    fromIso: string;
+    /** End of the range to resolve, in ISO format (exclusive). */
+    untilIso: string;
+    /** IANA time zone the schedule's wall-clock times are expressed in. */
+    timezone: string;
+    /** Optional start of the component's validity in ISO format (inclusive). */
+    validFromIso?: string;
+    /** Optional end of the component's validity in ISO format (exclusive). */
+    validUntilIso?: string;
+}
+/**
+ * Expands a price schedule into a flat 15-minute series over a time range.
+ *
+ * The range start is rounded down to the enclosing 15-minute interval. Intervals
+ * no window covers resolve to `amountPerKwh: 0`; intervals outside the
+ * component's validity window are omitted entirely, so an empty result means
+ * "this component does not apply here" rather than "it is free here".
+ *
+ * Windows are evaluated in array order and the first match wins — schedules are
+ * expected to be overlap-free, which the validators enforce at registration
+ * time.
+ *
+ * @param schedule - The schedule to expand
+ * @param options - Range, time zone and optional validity bounds
+ * @returns Resolved entries sorted ascending by `timestampIso`
+ *
+ * @example
+ * ```typescript
+ * const entries = resolvePriceSchedule(
+ *     {
+ *         type: EnyoPriceScheduleTypeEnum.Recurring,
+ *         windows: [{ startTimeOfDay: '22:00', endTimeOfDay: '06:00', amountPerKwh: 0.05 }],
+ *     },
+ *     { fromIso: '2026-09-02T00:00:00Z', untilIso: '2026-09-03T00:00:00Z', timezone: 'Europe/Berlin' },
+ * );
+ * ```
+ */
+export declare function resolvePriceSchedule(schedule: EnyoPriceSchedule, options: ResolvePriceScheduleOptions): EnyoResolvedPriceEntry[];

package/dist/cjs/index.cjs

@@ -152,3 +152,10 @@ __exportStar(require("./packages/energy-app-epex-spot-price.cjs"), exports);
 __exportStar(require("./types/enyo-automation.cjs"), exports);
 __exportStar(require("./packages/energy-app-automation.cjs"), exports);
 __exportStar(require("./implementations/automation/automation-validators.cjs"), exports);
+__exportStar(require("./types/enyo-price-schedule.cjs"), exports);
+__exportStar(require("./types/enyo-grid-fee.cjs"), exports);
+__exportStar(require("./types/enyo-price-composition.cjs"), exports);
+__exportStar(require("./packages/energy-app-grid-fee.cjs"), exports);
+__exportStar(require("./implementations/pricing/price-schedule-resolver.cjs"), exports);
+__exportStar(require("./implementations/pricing/price-component-validators.cjs"), exports);
+__exportStar(require("./implementations/pricing/compose-electricity-prices.cjs"), exports);

package/dist/cjs/index.d.cts

@@ -136,3 +136,10 @@ export * from './packages/energy-app-epex-spot-price.cjs';
 export * from './types/enyo-automation.cjs';
 export * from './packages/energy-app-automation.cjs';
 export * from './implementations/automation/automation-validators.cjs';
+export * from './types/enyo-price-schedule.cjs';
+export * from './types/enyo-grid-fee.cjs';
+export * from './types/enyo-price-composition.cjs';
+export * from './packages/energy-app-grid-fee.cjs';
+export * from './implementations/pricing/price-schedule-resolver.cjs';
+export * from './implementations/pricing/price-component-validators.cjs';
+export * from './implementations/pricing/compose-electricity-prices.cjs';

package/dist/cjs/packages/energy-app-electricity-tariff.d.cts

@@ -1,4 +1,4 @@
-import { EnyoElectricityTariff, EnyoElectricityTariffWithDefault } from "../types/enyo-electricity-tariff.cjs";
+import { EnyoElectricityTariff, EnyoElectricityTariffWithDefault, EnyoTariffChangeEvent } from "../types/enyo-electricity-tariff.cjs";
 /**
  * Interface for managing electricity tariffs.
  * Provides methods to register, retrieve, and remove electricity tariffs
@@ -60,4 +60,37 @@ export interface EnergyAppElectricityTariff {
      * @returns Promise that resolves to the full updated tariff with its default indicator
      */
     updateTariff(id: string, attributes: Partial<Omit<EnyoElectricityTariff, 'id'>>): Promise<EnyoElectricityTariffWithDefault>;
+    /**
+     * Registers a listener invoked whenever any tariff is registered, updated
+     * or removed, or whenever a different tariff becomes the system default.
+     *
+     * Listeners see changes made by every energy app on the system, not just
+     * this one — filter on {@link EnyoTariffChangeEvent.tariffId} when only one
+     * tariff matters. This is the signal to recompose prices: a changed grid fee
+     * link, an added or expired bonus, or a new default tariff all invalidate a
+     * previously composed price series.
+     *
+     * Requires the `ElectricityTariff` permission.
+     *
+     * @param listener - Callback invoked with the tariff change event
+     * @returns A unique listener id that can be passed to {@link offTariffChanged}
+     *
+     * @example
+     * ```typescript
+     * const listenerId = tariffs.onTariffChanged(async event => {
+     *     if (event.changeType === EnyoTariffChangeTypeEnum.Removed) return;
+     *     await recomposePrices(event.tariff);
+     * });
+     * // later
+     * tariffs.offTariffChanged(listenerId);
+     * ```
+     */
+    onTariffChanged(listener: (event: EnyoTariffChangeEvent) => void | Promise<void>): string;
+    /**
+     * Removes a previously registered tariff change listener. If the listener id
+     * is unknown, this operation is a no-op.
+     *
+     * @param listenerId - The id returned from {@link onTariffChanged}
+     */
+    offTariffChanged(listenerId: string): void;
 }

package/dist/cjs/packages/energy-app-grid-fee.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/packages/energy-app-grid-fee.d.cts

@@ -0,0 +1,181 @@
+import { EnyoDynamicGridFee, EnyoDynamicGridFeeFilter, EnyoDynamicGridFeeRegistration, EnyoDynamicGridFeeSeries, EnyoGridFeeChangeEvent } from '../types/enyo-grid-fee.cjs';
+import { EnyoAbsolutePriceWindow } from '../types/enyo-price-schedule.cjs';
+/**
+ * Interface for publishing and consuming dynamic grid fees (network charges).
+ *
+ * Any energy app can act as a producer by registering a grid fee — typically an
+ * app that knows the local grid operator's tariff sheet or fetches a published
+ * series — and any energy app can act as a consumer by resolving that fee for a
+ * time range with {@link getDynamicGridFees}.
+ *
+ * Publishing requires the `GridFeeRegister` permission; consuming requires
+ * `GridFeeUse`.
+ *
+ * A grid fee describes the site's **grid connection**, not a supplier contract:
+ * it is registered and resolved independently of any tariff, and the same fee
+ * applies whichever supplier the site buys from.
+ *
+ * **Nothing here is applied to a price automatically.** The host never folds a
+ * grid fee into {@link EnergyAppEnergyPrices.getPrices}, because provider APIs
+ * differ: some already return grid-fee-inclusive prices, some do not. The app
+ * that owns the tariff knows which is the case — it declares it via the
+ * tariff's `priceComposition` and composes the effective price itself with
+ * `composeElectricityPrices()`.
+ *
+ * @example
+ * ```typescript
+ * // Producer: a §14a EnWG module 3 HT/NT network charge
+ * const gridFee = energyApp.useGridFee();
+ * await gridFee.registerGridFee({
+ *     id: 'dso-hd-2026',
+ *     name: 'Netzentgelt HT/NT 2026',
+ *     gridOperator: 'Netze BW',
+ *     currency: EnyoCurrencyEnum.EUR,
+ *     timezone: 'Europe/Berlin',
+ *     appliesTo: EnyoPriceAppliesToEnum.Consumption,
+ *     moduleThreeCompliant: true,
+ *     schedule: {
+ *         type: EnyoPriceScheduleTypeEnum.Recurring,
+ *         windows: [
+ *             { startTimeOfDay: '06:00', endTimeOfDay: '22:00', amountPerKwh: 0.0912 },
+ *             { startTimeOfDay: '22:00', endTimeOfDay: '06:00', amountPerKwh: 0.0431 },
+ *         ],
+ *     },
+ * });
+ *
+ * // Consumer: resolve it for the next 24 hours
+ * const fees = await gridFee.getDynamicGridFees({
+ *     fromIso: new Date().toISOString(),
+ *     untilIso: new Date(Date.now() + 86_400_000).toISOString(),
+ * });
+ * ```
+ */
+export interface EnergyAppGridFee {
+    /**
+     * Registers a new dynamic grid fee or updates an existing one. Uses upsert
+     * logic based on `id` — if a fee with the same id already exists it is
+     * replaced, otherwise a new one is created.
+     *
+     * Requires the `GridFeeRegister` permission.
+     *
+     * @param registration - The grid fee to register, including its schedule
+     * @returns Promise that resolves to the stored grid fee, including the host-assigned `publishedAtIso`
+     */
+    registerGridFee(registration: EnyoDynamicGridFeeRegistration): Promise<EnyoDynamicGridFee>;
+    /**
+     * Partially updates a registered grid fee. Only the provided attributes are
+     * modified; all other fields remain unchanged.
+     *
+     * Requires the `GridFeeRegister` permission.
+     *
+     * @param id - The unique identifier of the grid fee to update
+     * @param attributes - A partial set of grid fee fields to update (excluding `id`)
+     * @returns Promise that resolves to the full updated grid fee
+     */
+    updateGridFee(id: string, attributes: Partial<Omit<EnyoDynamicGridFeeRegistration, 'id'>>): Promise<EnyoDynamicGridFee>;
+    /**
+     * Removes a registered grid fee. {@link getDynamicGridFees} resolves to
+     * `null` for it afterwards. If the fee does not exist, this operation is a
+     * no-op.
+     *
+     * Requires the `GridFeeRegister` permission.
+     *
+     * @param id - The unique identifier of the grid fee to remove
+     * @returns Promise that resolves when the grid fee has been removed
+     */
+    removeGridFee(id: string): Promise<void>;
+    /**
+     * Retrieves all registered grid fees across all energy apps on the system.
+     *
+     * Requires the `GridFeeUse` permission.
+     *
+     * @returns Promise that resolves to an array of all registered grid fees
+     */
+    listGridFees(): Promise<EnyoDynamicGridFee[]>;
+    /**
+     * Retrieves a single registered grid fee by its id, or `null` when no fee
+     * with that id exists.
+     *
+     * Requires the `GridFeeUse` permission.
+     *
+     * @param id - The unique identifier of the grid fee
+     * @returns Promise that resolves to the grid fee, or `null`
+     */
+    getGridFee(id: string): Promise<EnyoDynamicGridFee | null>;
+    /**
+     * Replaces the absolute windows of a grid fee whose schedule is
+     * {@link EnyoPriceScheduleTypeEnum.Absolute}. Use this for fees the grid
+     * operator publishes as a dated series (for example day-ahead), where the
+     * schedule changes far more often than the fee's metadata.
+     *
+     * Windows must not overlap and are stored sorted ascending by `startIso`.
+     * Publishing replaces the previously stored windows in full.
+     *
+     * Requires the `GridFeeRegister` permission.
+     *
+     * @param id - The unique identifier of the registered grid fee
+     * @param windows - The complete set of absolute windows to store
+     * @returns Promise that resolves when the windows have been stored and change listeners dispatched
+     */
+    publishGridFeeWindows(id: string, windows: EnyoAbsolutePriceWindow[]): Promise<void>;
+    /**
+     * Resolves a dynamic grid fee to a flat **15-minute series** over the
+     * requested range — the same resolution
+     * {@link EnergyAppEnergyPrices.getPrices} uses, so both series can be
+     * combined interval by interval.
+     *
+     * The fee is selected by `gridFeeId` or `meteringPointId`; with no selector
+     * the grid fee that applies to this device is used. Grid fees are **not**
+     * bound to a tariff — a network charge is a property of the grid connection,
+     * and the same fee applies no matter which supplier the site buys from.
+     * Returns `null` when no fee matches the selector.
+     *
+     * Intervals no window covers resolve to `feePerKwh: 0`, and intervals
+     * outside the fee's `validFromIso` / `validUntilIso` window are omitted.
+     *
+     * Requires the `GridFeeUse` permission.
+     *
+     * @param filter - The time range and the selector identifying which fee to resolve
+     * @returns Promise that resolves to the 15-minute fee series, or `null` when no fee applies
+     *
+     * @example
+     * ```typescript
+     * const fees = await gridFee.getDynamicGridFees({
+     *     fromIso: '2026-09-02T00:00:00Z',
+     *     untilIso: '2026-09-03T00:00:00Z',
+     * });
+     * fees?.entries.forEach(e => console.log(e.timestampIso, e.feePerKwh));
+     * ```
+     */
+    getDynamicGridFees(filter: EnyoDynamicGridFeeFilter): Promise<EnyoDynamicGridFeeSeries | null>;
+    /**
+     * Registers a listener invoked whenever any grid fee is registered, updated
+     * or removed — including when its absolute windows are republished.
+     *
+     * Use it to recompute composed prices without polling: a grid operator that
+     * publishes a new day-ahead series mid-day changes the cost of every future
+     * interval.
+     *
+     * Requires the `GridFeeUse` permission.
+     *
+     * @param listener - Callback invoked with the change event
+     * @returns A unique listener id that can be passed to {@link offGridFeeChanged}
+     *
+     * @example
+     * ```typescript
+     * const id = gridFee.onGridFeeChanged(async event => {
+     *     if (event.gridFeeId === myFeeId) await recomputePrices();
+     * });
+     * // later
+     * gridFee.offGridFeeChanged(id);
+     * ```
+     */
+    onGridFeeChanged(listener: (event: EnyoGridFeeChangeEvent) => void | Promise<void>): string;
+    /**
+     * Removes a previously registered grid fee change listener. If the listener
+     * id is unknown, this operation is a no-op.
+     *
+     * @param listenerId - The id returned from {@link onGridFeeChanged}
+     */
+    offGridFeeChanged(listenerId: string): void;
+}

package/dist/cjs/types/enyo-electricity-tariff.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElectricityTariffTypeEnum = void 0;
+exports.EnyoTariffChangeTypeEnum = exports.GridFeeModeEnum = exports.ElectricityTariffTypeEnum = void 0;
 /**
  * Enum representing the type of electricity tariff pricing model
  */
@@ -13,3 +13,35 @@ var ElectricityTariffTypeEnum;
     /** Price changes dynamically based on market conditions */
     ElectricityTariffTypeEnum["Dynamic"] = "dynamic";
 })(ElectricityTariffTypeEnum || (exports.ElectricityTariffTypeEnum = ElectricityTariffTypeEnum = {}));
+/**
+ * How the grid fee (network charge) of a tariff is determined.
+ */
+var GridFeeModeEnum;
+(function (GridFeeModeEnum) {
+    /**
+     * A single constant fee per kWh, carried by the tariff itself
+     * (see {@link DynamicTariffData.gridFeePerKwh}).
+     */
+    GridFeeModeEnum["Static"] = "static";
+    /**
+     * A time-dependent fee, read from the grid fee API with
+     * `useGridFee().getDynamicGridFees()`. The tariff only declares *that* the
+     * fee is time-dependent — which fee applies is a property of the site's grid
+     * connection, not of the tariff.
+     */
+    GridFeeModeEnum["Dynamic"] = "dynamic";
+})(GridFeeModeEnum || (exports.GridFeeModeEnum = GridFeeModeEnum = {}));
+/**
+ * What happened to a tariff registration.
+ */
+var EnyoTariffChangeTypeEnum;
+(function (EnyoTariffChangeTypeEnum) {
+    /** A new tariff was registered. */
+    EnyoTariffChangeTypeEnum["Registered"] = "registered";
+    /** An existing tariff's attributes, grid fee link or bonuses changed. */
+    EnyoTariffChangeTypeEnum["Updated"] = "updated";
+    /** A tariff was removed. */
+    EnyoTariffChangeTypeEnum["Removed"] = "removed";
+    /** A different tariff became the system default. */
+    EnyoTariffChangeTypeEnum["DefaultChanged"] = "default-changed";
+})(EnyoTariffChangeTypeEnum || (exports.EnyoTariffChangeTypeEnum = EnyoTariffChangeTypeEnum = {}));

package/dist/cjs/types/enyo-electricity-tariff.d.cts

@@ -1,3 +1,4 @@
+import { EnyoPriceAppliesToEnum, EnyoPriceSchedule } from './enyo-price-schedule.cjs';
 /**
  * Enum representing the type of electricity tariff pricing model
  */
@@ -9,10 +10,119 @@ export declare enum ElectricityTariffTypeEnum {
     /** Price changes dynamically based on market conditions */
     Dynamic = "dynamic"
 }
+/**
+ * How the grid fee (network charge) of a tariff is determined.
+ */
+export declare enum GridFeeModeEnum {
+    /**
+     * A single constant fee per kWh, carried by the tariff itself
+     * (see {@link DynamicTariffData.gridFeePerKwh}).
+     */
+    Static = "static",
+    /**
+     * A time-dependent fee, read from the grid fee API with
+     * `useGridFee().getDynamicGridFees()`. The tariff only declares *that* the
+     * fee is time-dependent — which fee applies is a property of the site's grid
+     * connection, not of the tariff.
+     */
+    Dynamic = "dynamic"
+}
+/**
+ * Declares how the grid fee (network charge) that applies alongside a tariff is
+ * determined.
+ *
+ * Mixed into every tariff pricing shape: a fixed energy price combined with
+ * time-variable network charges (e.g. §14a EnWG module 3) is just as real a
+ * product as a spot-market tariff, so the declaration is not exclusive to
+ * dynamic tariffs.
+ *
+ * A grid fee itself is **not** bound to a tariff — it belongs to the site's grid
+ * connection and is registered and resolved through `useGridFee()` independently.
+ * The tariff only says whether its grid fee is a constant it carries itself or a
+ * time-dependent one to be read from that API.
+ *
+ * The grid fee is never applied automatically. Energy apps read the fee and
+ * compose the effective price themselves — see `composeElectricityPrices()`.
+ */
+export interface TariffGridFeeConfig {
+    /**
+     * How the grid fee is determined. Defaults to {@link GridFeeModeEnum.Static}
+     * when omitted, so tariffs registered before this field existed keep their
+     * previous behaviour.
+     *
+     * {@link GridFeeModeEnum.Dynamic} must not be combined with
+     * `priceComposition.includesGridFee === true` — a fee already contained in
+     * the tariff's prices must not be added again.
+     */
+    gridFeeMode?: GridFeeModeEnum;
+}
+/**
+ * Declares which cost components are **already contained** in the prices this
+ * tariff yields.
+ *
+ * Provider APIs differ: some return all-in prices with network charges, levies
+ * and taxes baked in, others return the pure energy price. Consumers must never
+ * add a component that is already included — this declaration is what makes the
+ * difference machine-readable instead of tribal knowledge.
+ *
+ * When omitted, prices are treated as **energy price only**.
+ */
+export interface TariffPriceCompositionInfo {
+    /** `true` when the tariff's prices already contain the grid fee. */
+    includesGridFee: boolean;
+    /** `true` when the tariff's prices already contain taxes and levies. */
+    includesTaxesAndLevies?: boolean;
+    /** `true` when the tariff's prices already have its bonuses applied. */
+    includesBonuses?: boolean;
+}
+/**
+ * A time-dependent discount granted on top of a tariff, expressed in currency
+ * per kWh — for example "5 ct/kWh cheaper between 22:00 and 06:00" or a
+ * promotional rebate that runs for a fixed number of months.
+ *
+ * A tariff may carry several bonuses. Amounts in {@link schedule} are positive
+ * magnitudes and are **subtracted** from the price.
+ *
+ * Consumption-quota bonuses ("the first 100 kWh each month are free") are not
+ * expressible here — they require consumption accounting that this model
+ * deliberately does not carry.
+ */
+export interface EnyoTariffBonus {
+    /** Unique identifier of the bonus within its tariff. */
+    id: string;
+    /** Human-readable name shown to the user, e.g. `'Nachtbonus'`. */
+    name: string;
+    /**
+     * When and how much the discount is. Amounts are positive and subtracted
+     * from the price.
+     */
+    schedule: EnyoPriceSchedule;
+    /**
+     * IANA time zone the schedule's wall-clock times are expressed in, e.g.
+     * `'Europe/Berlin'`.
+     */
+    timezone: string;
+    /** Whether the bonus applies to consumption, feed-in, or both. */
+    appliesTo: EnyoPriceAppliesToEnum;
+    /** Optional start of the bonus's validity in ISO format (inclusive). */
+    validFromIso?: string;
+    /** Optional end of the bonus's validity in ISO format (exclusive). */
+    validUntilIso?: string;
+    /**
+     * When `true`, this bonus suppresses every lower-priority bonus in the
+     * intervals it covers instead of stacking with them.
+     */
+    exclusive?: boolean;
+    /**
+     * Ranking used to pick between competing exclusive bonuses — higher wins.
+     * Defaults to `0`.
+     */
+    priority?: number;
+}
 /**
  * Pricing data for a static (fixed-price) electricity tariff
  */
-export interface StaticTariffData {
+export interface StaticTariffData extends TariffGridFeeConfig {
     /** Price per kWh for consumption */
     pricePerKwh: number;
     /** Currency code (ISO 4217, e.g., 'EUR', 'USD') */
@@ -21,8 +131,15 @@ export interface StaticTariffData {
 /**
  * Pricing data for a dynamic electricity tariff
  */
-export interface DynamicTariffData {
-    /** Price per kWh for grid fees */
+export interface DynamicTariffData extends TariffGridFeeConfig {
+    /**
+     * Constant price per kWh for grid fees.
+     *
+     * @deprecated Set {@link TariffGridFeeConfig.gridFeeMode} to
+     * {@link GridFeeModeEnum.Dynamic} and read the fee from
+     * `useGridFee().getDynamicGridFees()` instead. Still honoured as the
+     * constant fallback while `gridFeeMode` is Static or omitted.
+     */
     gridFeePerKwh?: number;
     /** Currency code (ISO 4217, e.g., 'EUR', 'USD') */
     currency: string;
@@ -39,7 +156,7 @@ export interface TimeVariableScheduleEntry {
 /**
  * Pricing data for a time-variable electricity tariff
  */
-export interface TimeVariableTariffData {
+export interface TimeVariableTariffData extends TariffGridFeeConfig {
     /** Schedule of time-based price entries */
     schedule: TimeVariableScheduleEntry[];
     /** Currency code (ISO 4217, e.g., 'EUR', 'USD') */
@@ -67,6 +184,17 @@ export interface EnyoElectricityTariff {
     dynamicTariffData?: DynamicTariffData;
     /** Optional external tariff id for easy identification */
     externalTariffId?: string;
+    /**
+     * Optional declaration of which cost components the tariff's prices already
+     * contain. Omitted means "energy price only".
+     */
+    priceComposition?: TariffPriceCompositionInfo;
+    /**
+     * Optional discounts granted on top of this tariff. Several bonuses may
+     * apply at the same time — overlapping bonuses stack additively unless one
+     * of them is {@link EnyoTariffBonus.exclusive}.
+     */
+    bonuses?: EnyoTariffBonus[];
 }
 /**
  * Tariff registration data extended with default indicator.
@@ -76,3 +204,32 @@ export interface EnyoElectricityTariffWithDefault extends EnyoElectricityTariff
     /** Indicates whether this tariff is the system default */
     defaultTariff: boolean;
 }
+/**
+ * What happened to a tariff registration.
+ */
+export declare enum EnyoTariffChangeTypeEnum {
+    /** A new tariff was registered. */
+    Registered = "registered",
+    /** An existing tariff's attributes, grid fee link or bonuses changed. */
+    Updated = "updated",
+    /** A tariff was removed. */
+    Removed = "removed",
+    /** A different tariff became the system default. */
+    DefaultChanged = "default-changed"
+}
+/**
+ * Event delivered to listeners registered via
+ * {@link EnergyAppElectricityTariff.onTariffChanged}.
+ */
+export interface EnyoTariffChangeEvent {
+    /** What happened. */
+    changeType: EnyoTariffChangeTypeEnum;
+    /** Identifier of the affected tariff. */
+    tariffId: string;
+    /**
+     * The tariff after the change, or `null` when it was removed. For
+     * {@link EnyoTariffChangeTypeEnum.DefaultChanged} this is the tariff that
+     * became the new default.
+     */
+    tariff: EnyoElectricityTariffWithDefault | null;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnyoGridFeeChangeTypeEnum = void 0;
+/**
+ * What happened to a grid fee registration.
+ */
+var EnyoGridFeeChangeTypeEnum;
+(function (EnyoGridFeeChangeTypeEnum) {
+    /** A new grid fee was registered. */
+    EnyoGridFeeChangeTypeEnum["Registered"] = "registered";
+    /** An existing grid fee's attributes or schedule changed. */
+    EnyoGridFeeChangeTypeEnum["Updated"] = "updated";
+    /** A grid fee was removed. */
+    EnyoGridFeeChangeTypeEnum["Removed"] = "removed";
+})(EnyoGridFeeChangeTypeEnum || (exports.EnyoGridFeeChangeTypeEnum = EnyoGridFeeChangeTypeEnum = {}));