node-red-contrib-s2 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [0.1.0]
+
+### Added
+
+- `s2-rm` node: S2 Resource Manager session handling (handshake, control type selection, instructions).
+- `s2-rm-config` / `s2-cem-config` nodes for RM identity and CEM connection configuration.
+- `s2-websocket` node: WebSocket transport to a CEM, with reconnect/backoff handling.
+- Operation Mode Based Control (OMBC) and Power Envelope Based Control (PEBC) support.
+- PowerMeasurement and PowerForecast forwarding.
+- Multiple concurrent CEM sessions.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victron Energy BV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# node-red-contrib-s2
+
+Node-RED nodes for the [S2 energy management protocol](https://s2standard.org/) (EN 50491-12-2).
+
+S2 is a European standard for demand-side energy flexibility. It defines how a Customer Energy Manager (CEM) communicates with Resource Managers (RMs) to coordinate energy consumption, production, and storage.
+
+## Requirements
+
+- Node-RED >= 4.1.0
+- Node.js >= 24
+
+## Nodes
+
+| Node | Description |
+|------|-------------|
+| **s2-rm** | S2 Resource Manager - manages protocol sessions with one or more CEMs |
+| **s2-rm-config** | Configuration for RM identity: resource ID, name, roles, control types, serial number |
+| **s2-cem-config** | Configuration for CEM connection (WebSocket URL and credentials) |
+| **s2-websocket** | WebSocket transport for S2 communication with a CEM |
+
+## Features
+
+- S2 protocol handshake and session management
+- Operation Mode Based Control (OMBC)
+- Power Envelope Based Control (PEBC) with configurable power constraints
+- PowerMeasurement forwarding (3-phase symmetric or per-phase L1/L2/L3)
+- PowerForecast support
+- Multiple concurrent CEM sessions
+- Configurable RM roles (Consumer, Producer, Storage)
+- Context variable templates in serial number (e.g. `{{global.vrmId}}`)
+
+## Installation
+
+Install via the Node-RED palette manager, or from the command line:
+
+```bash
+cd ~/.node-red
+npm install node-red-contrib-s2
+```
+
+## Quick start
+
+1. Add an **s2-rm-config** node and configure your Resource Manager identity (name, roles, control types).
+2. Add an **s2-cem-config** node with the WebSocket URL and credentials of your CEM.
+3. Wire an **s2-websocket** node to an **s2-rm** node:
+   - s2-websocket output 2 -> s2-rm input
+   - s2-rm output 1 -> s2-websocket input
+4. s2-rm output 2 carries S2 messages from the CEM (e.g. SelectControlType, ReceptionStatus).
+5. s2-rm output 3 carries instructions from the CEM (e.g. PEBC.Instruction, OMBC.Instruction).
+
+## Sending PowerMeasurements
+
+To send power measurements to the CEM, inject a message into the s2-rm input:
+
+```json
+{
+  "payload": {
+    "command": "PowerMeasurement",
+    "cemId": "cem",
+    "values": [
+      { "commodity_quantity": "ELECTRIC.POWER.3_PHASE_SYMMETRIC", "value": 1500 }
+    ]
+  }
+}
+```
+
+The s2-rm node emits a `PowerMeasurementStart` signal on output 1 when the CEM selects a control type, so you can use that to trigger periodic measurements.
+
+## Sending PowerForecasts
+
+```json
+{
+  "payload": {
+    "command": "Forecast",
+    "cemId": "cem",
+    "forecast": {
+      "startTime": "2026-04-14T10:00:00Z",
+      "elements": [
+        {
+          "duration": 900000,
+          "power_values": [
+            { "commodity_quantity": "ELECTRIC.POWER.3_PHASE_SYMMETRIC", "value_expected": 1500 }
+          ]
+        }
+      ]
+    }
+  }
+}
+```
+
+## Updating PEBC PowerConstraints
+
+```json
+{
+  "payload": {
+    "command": "PowerConstraints",
+    "cemId": "cem",
+    "constraints": {
+      "commodityQuantity": "ELECTRIC.POWER.3_PHASE_SYMMETRIC",
+      "minPower": -3000,
+      "maxPower": 3000
+    }
+  }
+}
+```
+
+Constraints are stored at the node level and automatically sent when a CEM selects PEBC.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+## License
+
+[MIT](LICENSE) - Copyright (c) 2026 Victron Energy BV

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { S2Session, State } from './s2/session';
+export type { StateValue, S2SessionOptions, ControlTypeConfig } from './s2/session';
+export { MessageType, ControlType, ReceptionStatusResult, parse, serialize, makeReceptionStatus, makeHandshake, makeResourceManagerDetails, generateId } from './s2/messages';
+export type { MessageTypeValue, ControlTypeValue, ReceptionStatusResultValue, S2IncomingMessage, S2Role, PowerMeasurementValue, RmDetails } from './s2/messages';

package/dist/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateId = exports.makeResourceManagerDetails = exports.makeHandshake = exports.makeReceptionStatus = exports.serialize = exports.parse = exports.ReceptionStatusResult = exports.ControlType = exports.MessageType = exports.State = exports.S2Session = void 0;
+var session_1 = require("./s2/session");
+Object.defineProperty(exports, "S2Session", { enumerable: true, get: function () { return session_1.S2Session; } });
+Object.defineProperty(exports, "State", { enumerable: true, get: function () { return session_1.State; } });
+var messages_1 = require("./s2/messages");
+Object.defineProperty(exports, "MessageType", { enumerable: true, get: function () { return messages_1.MessageType; } });
+Object.defineProperty(exports, "ControlType", { enumerable: true, get: function () { return messages_1.ControlType; } });
+Object.defineProperty(exports, "ReceptionStatusResult", { enumerable: true, get: function () { return messages_1.ReceptionStatusResult; } });
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return messages_1.parse; } });
+Object.defineProperty(exports, "serialize", { enumerable: true, get: function () { return messages_1.serialize; } });
+Object.defineProperty(exports, "makeReceptionStatus", { enumerable: true, get: function () { return messages_1.makeReceptionStatus; } });
+Object.defineProperty(exports, "makeHandshake", { enumerable: true, get: function () { return messages_1.makeHandshake; } });
+Object.defineProperty(exports, "makeResourceManagerDetails", { enumerable: true, get: function () { return messages_1.makeResourceManagerDetails; } });
+Object.defineProperty(exports, "generateId", { enumerable: true, get: function () { return messages_1.generateId; } });
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":";;;AAAA,wCAA+C;AAAtC,oGAAA,SAAS,OAAA;AAAE,gGAAA,KAAK,OAAA;AAGzB,0CAUsB;AATpB,uGAAA,WAAW,OAAA;AACX,uGAAA,WAAW,OAAA;AACX,iHAAA,qBAAqB,OAAA;AACrB,iGAAA,KAAK,OAAA;AACL,qGAAA,SAAS,OAAA;AACT,+GAAA,mBAAmB,OAAA;AACnB,yGAAA,aAAa,OAAA;AACb,sHAAA,0BAA0B,OAAA;AAC1B,sGAAA,UAAU,OAAA"}

package/dist/lib/s2/messages.d.ts

@@ -0,0 +1,342 @@
+/**
+ * S2 protocol message type constants (EN 50491-12-2).
+ * These are the message_type values used in S2 JSON messages.
+ */
+export declare const MessageType: Readonly<{
+    readonly HANDSHAKE: "Handshake";
+    readonly HANDSHAKE_RESPONSE: "HandshakeResponse";
+    readonly SESSION_REQUEST: "SessionRequest";
+    readonly RESOURCE_MANAGER_DETAILS: "ResourceManagerDetails";
+    readonly POWER_MEASUREMENT: "PowerMeasurement";
+    readonly RECEPTION_STATUS: "ReceptionStatus";
+    readonly REVOKE_OBJECT: "RevokeObject";
+    readonly SELECT_CONTROL_TYPE: "SelectControlType";
+    readonly INSTRUCTION: "Instruction";
+    readonly FRBC_ACTUATOR_STATUS: "FRBC.ActuatorStatus";
+    readonly FRBC_FILL_LEVEL_TARGET_PROFILE: "FRBC.FillLevelTargetProfile";
+    readonly FRBC_LEAKAGE_BEHAVIOUR: "FRBC.LeakagebBehaviour";
+    readonly FRBC_STORAGE_STATUS: "FRBC.StorageStatus";
+    readonly FRBC_SYSTEM_DESCRIPTION: "FRBC.SystemDescription";
+    readonly FRBC_TIMER_STATUS: "FRBC.TimerStatus";
+    readonly FRBC_USAGE_FORECAST: "FRBC.UsageForecast";
+    readonly FRBC_INSTRUCTION: "FRBC.Instruction";
+    readonly DDBC_ACTUAL_POWER: "DDBC.ActualPower";
+    readonly DDBC_AVERAGE_DEMAND_RATE_FORECAST: "DDBC.AverageDemandRateForecast";
+    readonly DDBC_SYSTEM_DESCRIPTION: "DDBC.SystemDescription";
+    readonly DDBC_TIMER_STATUS: "DDBC.TimerStatus";
+    readonly DDBC_INSTRUCTION: "DDBC.Instruction";
+    readonly PPBC_POWER_PROFILE_STATUS: "PPBC.PowerProfileStatus";
+    readonly PPBC_SCHEDULE_INSTRUCTION: "PPBC.ScheduleInstruction";
+    readonly PPBC_START_INTERRUPTION_INSTRUCTION: "PPBC.StartInterruptionInstruction";
+    readonly PPBC_END_INTERRUPTION_INSTRUCTION: "PPBC.EndInterruptionInstruction";
+    readonly PPBC_POWER_PROFILE: "PPBC.PowerProfileDefinition";
+    readonly OMBC_SYSTEM_DESCRIPTION: "OMBC.SystemDescription";
+    readonly OMBC_STATUS: "OMBC.Status";
+    readonly OMBC_INSTRUCTION: "OMBC.Instruction";
+    readonly PEBC_POWER_CONSTRAINTS: "PEBC.PowerConstraints";
+    readonly PEBC_DEVICE_CONSTRAINTS: "PEBC.DeviceConstraints";
+    readonly PEBC_ENERGY_CONSTRAINT: "PEBC.EnergyConstraint";
+    readonly PEBC_INSTRUCTION: "PEBC.Instruction";
+    readonly POWER_FORECAST: "PowerForecast";
+    readonly INSTRUCTION_STATUS_UPDATE: "InstructionStatusUpdate";
+}>;
+export type MessageTypeValue = (typeof MessageType)[keyof typeof MessageType];
+/**
+ * S2 control type identifiers (full names as used in s2python / s2-ws-json).
+ */
+export declare const ControlType: Readonly<{
+    readonly NOT_CONTROLABLE: "NOT_CONTROLABLE";
+    readonly OMBC: "OPERATION_MODE_BASED_CONTROL";
+    readonly FRBC: "FILL_RATE_BASED_CONTROL";
+    readonly DDBC: "DEMAND_DRIVEN_BASED_CONTROL";
+    readonly PPBC: "POWER_PROFILE_BASED_CONTROL";
+    readonly PEBC: "POWER_ENVELOPE_BASED_CONTROL";
+    readonly NO_SELECTION: "NO_SELECTION";
+}>;
+export type ControlTypeValue = (typeof ControlType)[keyof typeof ControlType];
+/**
+ * ReceptionStatus result values (matches s2python ReceptionStatusValues).
+ */
+/**
+ * Standard European grid connection types with their max power capacity at 230V nominal.
+ * Used to set PEBC power constraint outer limits (bidirectional: [-maxWatts, +maxWatts]).
+ */
+export declare const GRID_CONNECTIONS: Readonly<{
+    readonly '1x16A': {
+        readonly phases: 1;
+        readonly ampsPerPhase: 16;
+        readonly maxWatts: 3680;
+    };
+    readonly '3x16A': {
+        readonly phases: 3;
+        readonly ampsPerPhase: 16;
+        readonly maxWatts: 11040;
+    };
+    readonly '3x25A': {
+        readonly phases: 3;
+        readonly ampsPerPhase: 25;
+        readonly maxWatts: 17250;
+    };
+    readonly '3x32A': {
+        readonly phases: 3;
+        readonly ampsPerPhase: 32;
+        readonly maxWatts: 22080;
+    };
+    readonly '3x40A': {
+        readonly phases: 3;
+        readonly ampsPerPhase: 40;
+        readonly maxWatts: 27600;
+    };
+    readonly '3x63A': {
+        readonly phases: 3;
+        readonly ampsPerPhase: 63;
+        readonly maxWatts: 43470;
+    };
+}>;
+export type GridConnectionKey = keyof typeof GRID_CONNECTIONS;
+/**
+ * Returns the max power in watts for a given grid connection.
+ * For 'custom', returns customMaxPowerW if provided.
+ * Returns null if the connection is unknown or unset.
+ */
+export declare function gridConnectionToWatts(gridConnection: string | undefined, customMaxPowerW?: number): number | null;
+export declare const ReceptionStatusResult: Readonly<{
+    readonly OK: "OK";
+    readonly INVALID_DATA: "INVALID_DATA";
+    readonly INVALID_MESSAGE: "INVALID_MESSAGE";
+    readonly INVALID_CONTENT: "INVALID_CONTENT";
+    readonly TEMPORARY_ERROR: "TEMPORARY_ERROR";
+    readonly PERMANENT_ERROR: "PERMANENT_ERROR";
+}>;
+export type ReceptionStatusResultValue = (typeof ReceptionStatusResult)[keyof typeof ReceptionStatusResult];
+export declare const InstructionStatus: Readonly<{
+    readonly NEW: "NEW";
+    readonly ACCEPTED: "ACCEPTED";
+    readonly REJECTED: "REJECTED";
+    readonly REVOKED: "REVOKED";
+    readonly STARTED: "STARTED";
+    readonly SUCCEEDED: "SUCCEEDED";
+    readonly ABORTED: "ABORTED";
+}>;
+export type InstructionStatusValue = (typeof InstructionStatus)[keyof typeof InstructionStatus];
+export declare const RevokableObjects: Readonly<{
+    readonly DDBC_AVERAGE_DEMAND_RATE_FORECAST: "DDBC.AverageDemandRateForecast";
+    readonly DDBC_INSTRUCTION: "DDBC.Instruction";
+    readonly DDBC_SYSTEM_DESCRIPTION: "DDBC.SystemDescription";
+    readonly FRBC_FILL_LEVEL_TARGET_PROFILE: "FRBC.FillLevelTargetProfile";
+    readonly FRBC_INSTRUCTION: "FRBC.Instruction";
+    readonly FRBC_LEAKAGE_BEHAVIOUR: "FRBC.LeakageBehaviour";
+    readonly FRBC_SYSTEM_DESCRIPTION: "FRBC.SystemDescription";
+    readonly FRBC_USAGE_FORECAST: "FRBC.UsageForecast";
+    readonly OMBC_INSTRUCTION: "OMBC.Instruction";
+    readonly OMBC_SYSTEM_DESCRIPTION: "OMBC.SystemDescription";
+    readonly PEBC_ENERGY_CONSTRAINT: "PEBC.EnergyConstraint";
+    readonly PEBC_INSTRUCTION: "PEBC.Instruction";
+    readonly PEBC_POWER_CONSTRAINTS: "PEBC.PowerConstraints";
+    readonly PPBC_END_INTERRUPTION_INSTRUCTION: "PPBC.EndInterruptionInstruction";
+    readonly PPBC_POWER_PROFILE_DEFINITION: "PPBC.PowerProfileDefinition";
+    readonly PPBC_SCHEDULE_INSTRUCTION: "PPBC.ScheduleInstruction";
+    readonly PPBC_START_INTERRUPTION_INSTRUCTION: "PPBC.StartInterruptionInstruction";
+}>;
+export type RevokableObjectsValue = (typeof RevokableObjects)[keyof typeof RevokableObjects];
+/** Base shape for any S2 message parsed from JSON. */
+export interface S2IncomingMessage {
+    message_type: string;
+    message_id?: string;
+    [key: string]: unknown;
+}
+export interface S2Role {
+    role: string;
+    commodity: string;
+}
+export interface PowerMeasurementValue {
+    commodity_quantity: string;
+    value: number;
+}
+export interface S2HandshakeMessage {
+    message_type: typeof MessageType.HANDSHAKE;
+    message_id: string;
+    role: 'RM';
+    supported_protocol_versions: string[];
+}
+export interface S2ReceptionStatusMessage {
+    message_type: typeof MessageType.RECEPTION_STATUS;
+    subject_message_id: string;
+    status: ReceptionStatusResultValue;
+    diagnostic_label?: string;
+}
+export interface S2RevokeObjectMessage {
+    message_type: typeof MessageType.REVOKE_OBJECT;
+    message_id: string;
+    object_id: string;
+    object_type: RevokableObjectsValue;
+}
+export interface InstructionStatusUpdateMessage {
+    message_type: typeof MessageType.INSTRUCTION_STATUS_UPDATE;
+    message_id: string;
+    instruction_id: string;
+    status_type: InstructionStatusValue;
+    timestamp: string;
+}
+export interface S2ResourceManagerDetailsMessage {
+    message_type: typeof MessageType.RESOURCE_MANAGER_DETAILS;
+    message_id: string;
+    resource_id: string;
+    name: string;
+    roles: S2Role[];
+    manufacturer: string;
+    model: string;
+    serial_number: string;
+    firmware_version: string;
+    available_control_types: string[];
+    provides_forecast: boolean;
+    provides_power_measurement_types: string[];
+    instruction_processing_delay: number;
+}
+export interface S2OMBCSystemDescriptionMessage {
+    message_type: typeof MessageType.OMBC_SYSTEM_DESCRIPTION;
+    message_id: string;
+    valid_from: string;
+    operation_modes: unknown[];
+    transitions: unknown[];
+    timers: unknown[];
+}
+export interface S2OMBCStatusMessage {
+    message_type: typeof MessageType.OMBC_STATUS;
+    message_id: string;
+    active_operation_mode_id: string;
+    operation_mode_factor: number;
+    previous_operation_mode_id?: string;
+    transition_timestamp?: string;
+}
+export interface S2PowerMeasurementMessage {
+    message_type: typeof MessageType.POWER_MEASUREMENT;
+    message_id: string;
+    measurement_timestamp: string;
+    values: PowerMeasurementValue[];
+}
+export interface RmDetails {
+    resourceId: string;
+    name: string;
+    roles: S2Role[];
+    availableControlTypes: string[];
+    providesForecast: boolean;
+    providesPowerMeasurementTypes?: string[];
+    instructionProcessingDelay?: number;
+    manufacturer?: string;
+    model?: string;
+    serialNumber?: string;
+    firmwareVersion?: string;
+}
+export interface OMBCSystemDescriptionConfig {
+    operationModes: unknown[];
+    transitions?: unknown[];
+    timers?: unknown[];
+}
+export interface OMBCStatusConfig {
+    activeOperationModeId: string;
+    operationModeFactor?: number;
+    previousOperationModeId?: string;
+    transitionTimestamp?: string;
+}
+/**
+ * Simplified input for building a PEBC.PowerConstraints message.
+ * Produces a single commodity constraint with matching LOWER_LIMIT and
+ * UPPER_LIMIT ranges, consequence_type DEFER - as required by most CEMs.
+ */
+export interface PEBCPowerConstraintsInput {
+    /** e.g. 'ELECTRIC.POWER.3_PHASE_SYMMETRIC' */
+    commodityQuantity: string;
+    /** Lower bound of the allowed power range in Watts (may be negative for export) */
+    minPower: number;
+    /** Upper bound of the allowed power range in Watts */
+    maxPower: number;
+    /** ISO 8601 datetime; defaults to now */
+    validFrom?: string;
+}
+export interface PowerForecastValue {
+    commodity_quantity: string;
+    value_expected: number;
+    value_upper_limit?: number;
+    value_lower_limit?: number;
+}
+export interface PowerForecastElement {
+    duration: number;
+    power_values: PowerForecastValue[];
+}
+export interface PowerForecastInput {
+    startTime: string;
+    elements: PowerForecastElement[];
+}
+/**
+ * Parse a raw WebSocket message string into an S2 message object.
+ * Returns null and calls onError if parsing fails.
+ *
+ * @param raw - raw JSON string
+ * @param onError - called with an Error if parsing fails
+ */
+export declare function parse(raw: string, onError: (err: Error) => void): S2IncomingMessage | null;
+/**
+ * Serialize an S2 message object to a string for sending over the wire.
+ */
+export declare function serialize(msg: object): string;
+/**
+ * Create a ReceptionStatus message acknowledging a received message.
+ *
+ * @param subjectMessageId - message_id of the message being acknowledged
+ * @param status - one of ReceptionStatusResult values
+ * @param diagnosticLabel - optional human-readable diagnostic
+ */
+export declare function makeReceptionStatus(subjectMessageId: string, status: ReceptionStatusResultValue, diagnosticLabel?: string): S2ReceptionStatusMessage;
+/**
+ * Create a Handshake message (sent by RM on connect).
+ *
+ * @param rmId - unique ID identifying this Resource Manager
+ */
+export declare function makeHandshake(rmId: string): S2HandshakeMessage;
+/**
+ * Create a ResourceManagerDetails message (sent by RM after HandshakeResponse).
+ */
+export declare function makeResourceManagerDetails(details: RmDetails): S2ResourceManagerDetailsMessage;
+/**
+ * Create an OMBC.SystemDescription message.
+ */
+export declare function makeOMBCSystemDescription(config: OMBCSystemDescriptionConfig): S2OMBCSystemDescriptionMessage;
+/**
+ * Create an OMBC.Status message.
+ */
+export declare function makeOMBCStatus(status: OMBCStatusConfig): S2OMBCStatusMessage;
+/**
+ * Create a PowerMeasurement message (sent by RM to report current power).
+ *
+ * @param values - array of { commodity_quantity, value } objects
+ */
+export declare function makePowerMeasurement(values: PowerMeasurementValue[]): S2PowerMeasurementMessage;
+/**
+ * Build a PEBC.PowerConstraints message with matching LOWER_LIMIT and
+ * UPPER_LIMIT ranges and consequence_type DEFER.
+ *
+ * Wire format (s2-ws-json 0.0.2-beta):
+ *   id + allowed_limit_ranges are top-level fields on the message itself,
+ *   not nested under a power_constraints array.
+ */
+export declare function makePEBCPowerConstraints(input: PEBCPowerConstraintsInput): object;
+/**
+ * Build a PowerForecast message from pre-formed elements.
+ *
+ * @param input.startTime - ISO 8601 timezone-aware datetime for the first element
+ * @param input.elements - array of { duration (ms), power_values: [{ commodity_quantity, value_expected }] }
+ */
+export declare function makePowerForecast(input: PowerForecastInput): object;
+/**
+ * Create an InstructionStatusUpdate message reporting the current lifecycle state of an instruction.
+ *
+ * @param instructionId - the `id` field of the instruction (not its message_id)
+ * @param status - one of InstructionStatus values
+ */
+export declare function makeInstructionStatusUpdate(instructionId: string, status: InstructionStatusValue): InstructionStatusUpdateMessage;
+/**
+ * Generate a UUID v4 message ID.
+ * Node >=14.17.4 is required, which includes crypto.randomUUID.
+ */
+export declare function generateId(): string;