node-red-contrib-uos-nats 0.1.0

package/README.md

@@ -0,0 +1,92 @@
+# node-red-contrib-uos-nats
+
+**Note:** This custom Node-RED package is built and maintained by [IoTUeli](https://www.iotueli.ch) and is **not** an official Weidmüller product. For questions, feature requests, or support please contact IoTUeli directly.
+
+Node-RED nodes to read and write u-OS Data Hub variables via NATS. This package exposes three building blocks:
+
+1. **u-OS Config** – stores host, OAuth client credentials and manages the shared NATS connection.
+2. **DataHub Input** – subscribes to an existing provider, lets you pick individual variables and emits JSON messages.
+3. **DataHub Output** – automatically registers a provider (default `nodered`), flattens incoming JSON structures and publishes them to the Data Hub.
+
+The nodes reuse the FlatBuffer helpers from the standalone Node sample, so they speak the native NATS API.
+
+## Installation
+
+```bash
+cd ~/App/NATS-NodeRED
+npm install
+```
+
+Then install the nodes into your Node-RED user directory (e.g. `~/.node-red`):
+
+```bash
+cd ~/.node-red
+npm install ~/App/NATS-NodeRED
+```
+
+Restart Node-RED. You will find the nodes under the *u-OS Data Hub* category.
+
+## u-OS Config Node
+
+Fields:
+
+- **Host / Port** – IP address of your controller (e.g. `192.168.10.100`) and the NATS port `49360`.
+- **Client Name** – used for the NATS inbox prefix (`_INBOX.<name>`).
+- **Client ID / Secret** – OAuth2 client credentials created in the Control Center.
+- **Token URL** – optional override, defaults to `https://<host>/oauth2/token`.
+- **Scope** – usually `hub.variables.provide hub.variables.readwrite`.
+
+The config node automatically fetches tokens via Client Credentials flow and exposes helper endpoints so other nodes can list providers and variables.
+
+## DataHub Input Node
+
+- Select the u-OS config node and pick a provider from the drop-down. The node queries `/datahub/v1/providers` and lists all registry entries.
+- Choose whether you want **all variables**, **single variable**, or **multi selection**. The variable selector is populated from `/datahub/v1/providers/<provider>/variables`.
+- The node outputs messages with the structure:
+  ```json
+  {
+    "type": "snapshot" | "change",
+    "variables": [
+      {
+        "providerId": "sampleprovider",
+        "id": 5,
+        "key": "diagnostics.status_text",
+        "value": "running",
+        "quality": "GOOD",
+        "timestampNs": 1700000000000
+      }
+    ]
+  }
+  ```
+- Deploy multiple nodes if you want to monitor different providers.
+
+## DataHub Output Node
+
+- Reuses the u-OS config node. The provider ID defaults to `nodered` and is created automatically.
+- Send a JSON object to the input pin. Nested objects become dot-separated keys (e.g. `{ "line1": { "status": "ok" } }` ⇒ `line1.status`).
+- The node infers data types (INT64/FLOAT64/BOOLEAN/STRING) and publishes `VariablesChangedEvent`s. New keys trigger an automatic provider definition update.
+- Read requests (`v1.loc.<provider>.vars.qry.read`) are answered using the most recent values, so other consumers can subscribe to your Node-RED provider.
+
+## Docker (optional)
+
+A simple Dockerfile is included for development/testing:
+
+```bash
+docker build -t node-red-uos-nats .
+```
+
+Run with environment overrides for host and credentials if needed.
+
+## Example Flow
+
+1. Drop a **u-OS Config** node, fill in host/port and OAuth credentials from the Control Center.
+2. Add a **DataHub Input** node, select the config, pick an existing provider (e.g. `u_os_adm`) and choose the variables you want to observe. Connect the output to a Debug node.
+3. Add a **DataHub Output** node, leave provider ID = `nodered` and send structured JSON (e.g. from a Function node). The values instantly appear in the Data Hub under the provider `nodered`.
+
+> Tip: Because both nodes rely on the Control Center HTTP API for metadata they inherit the same permissions as your OAuth client. Make sure the client has at least `hub.variables.readonly` for the input node and `hub.variables.provide hub.variables.readwrite` for the output node.
+
+## TODO
+
+- Export a sample Node-RED flow (`flows.json`).
+- Optional helper node for write commands targeting existing providers.
+- Automated tests.

package/icons/white/datahub-input.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ffffff">
+  <rect x="3" y="3" width="18" height="18" rx="4" ry="4" opacity="0.25" fill="#ffffff" />
+  <path d="M12 6v8.5l3-3 1.5 1.5L12 18l-4.5-4.5L9 11.9l3 3V6z" />
+</svg>

package/icons/white/datahub-output.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ffffff">
+  <rect x="3" y="3" width="18" height="18" rx="4" ry="4" opacity="0.25" fill="#ffffff" />
+  <path d="M12 18V9.5l-3 3-1.5-1.5L12 6l4.5 4.5L15 11.6l-3-3V18z" />
+</svg>

package/lib/auth.js

@@ -0,0 +1,27 @@
+import fetch from 'node-fetch';
+import { CLIENT_ID, CLIENT_SECRET, TOKEN_ENDPOINT, TOKEN_SCOPE } from './config.js';
+export async function requestToken() {
+    const params = new URLSearchParams({
+        grant_type: 'client_credentials',
+        scope: TOKEN_SCOPE,
+    });
+    const basic = Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64');
+    const response = await fetch(TOKEN_ENDPOINT, {
+        method: 'POST',
+        headers: {
+            Authorization: `Basic ${basic}`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json',
+        },
+        body: params,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Token request failed: ${response.status} ${text}`);
+    }
+    const json = (await response.json());
+    if (!json.access_token) {
+        throw new Error('Token response missing access_token');
+    }
+    return json.access_token;
+}

package/lib/config.js

@@ -0,0 +1,23 @@
+import 'dotenv/config';
+export const HUB_HOST = process.env.HUB_HOST ?? '192.168.10.108';
+export const HUB_PORT = Number(process.env.HUB_PORT ?? 49360);
+export const PROVIDER_ID = process.env.PROVIDER_ID ?? 'sampleprovider';
+export const CLIENT_NAME = process.env.CLIENT_NAME ?? 'sampleprovider';
+export const CLIENT_ID = process.env.CLIENT_ID ?? '';
+export const CLIENT_SECRET = process.env.CLIENT_SECRET ?? '';
+export const TOKEN_SCOPE = process.env.TOKEN_SCOPE ?? 'hub.variables.provide hub.variables.readwrite';
+export const TOKEN_ENDPOINT = process.env.TOKEN_ENDPOINT ?? `https://${HUB_HOST}/oauth2/token`;
+export const PUBLISH_INTERVAL_MS = Number(process.env.PUBLISH_INTERVAL_MS ?? 1000);
+export const NATS_SERVER = process.env.NATS_SERVER ?? `nats://${HUB_HOST}:${HUB_PORT}`;
+if (!process.env.NODE_TLS_REJECT_UNAUTHORIZED) {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+}
+if (!CLIENT_ID || !CLIENT_SECRET) {
+    console.warn('[config] CLIENT_ID/CLIENT_SECRET fehlen – bitte .env ausfüllen.');
+}
+export const VARIABLE_DEFINITIONS = [
+    { id: 5, key: 'diagnostics.status_text', dataType: 'STRING', access: 'READ_WRITE' },
+    { id: 6, key: 'diagnostics.error_count', dataType: 'INT64', access: 'READ_WRITE' },
+    { id: 7, key: 'diagnostics.temperature', dataType: 'FLOAT64', access: 'READ_ONLY' },
+    { id: 8, key: 'diagnostics.is_running', dataType: 'BOOLEAN', access: 'READ_WRITE' },
+];

package/lib/consumer.js

@@ -0,0 +1,41 @@
+import { connect } from 'nats';
+import * as flatbuffers from 'flatbuffers';
+import { requestToken } from './auth.js';
+import { CLIENT_NAME, NATS_SERVER, PROVIDER_ID } from './config.js';
+import { buildReadVariablesQuery, decodeVariableList } from './payloads.js';
+import { readVariablesQuery, varsChangedEvent } from './subjects.js';
+import { ReadVariablesQueryResponse } from './fbs/weidmueller/ucontrol/hub/read-variables-query-response.js';
+import { VariablesChangedEvent } from './fbs/weidmueller/ucontrol/hub/variables-changed-event.js';
+async function main() {
+    console.log(`[consumer] Lausche auf Provider ${PROVIDER_ID}`);
+    const token = await requestToken();
+    const nc = await connect({
+        servers: NATS_SERVER.split(','),
+        token,
+        name: `${CLIENT_NAME}-node-consumer`,
+        inboxPrefix: `_INBOX.${CLIENT_NAME}`,
+    });
+    console.log('[consumer] NATS verbunden:', nc.getServer());
+    const snapshotMsg = await nc.request(readVariablesQuery(PROVIDER_ID), buildReadVariablesQuery(), {
+        timeout: 2000,
+    });
+    const snapshotBuffer = new flatbuffers.ByteBuffer(snapshotMsg.data);
+    const snapshotResponse = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(snapshotBuffer);
+    const initialStates = decodeVariableList(snapshotResponse.variables());
+    console.log('[consumer] Snapshot:', initialStates);
+    const sub = nc.subscribe(varsChangedEvent(PROVIDER_ID));
+    (async () => {
+        for await (const msg of sub) {
+            const buffer = new flatbuffers.ByteBuffer(msg.data);
+            const event = VariablesChangedEvent.getRootAsVariablesChangedEvent(buffer);
+            const states = decodeVariableList(event.changedVariables());
+            if (states.length === 0)
+                continue;
+            console.log('[consumer] Änderung erhalten:', states);
+        }
+    })().catch((err) => console.error('[consumer] Subscription error', err));
+}
+main().catch((err) => {
+    console.error('[consumer] Fehler:', err);
+    process.exit(1);
+});

package/lib/fbs/weidmueller/ucontrol/hub/duration.js

@@ -0,0 +1,67 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/**
+ * A Duration represents a signed, fixed-length span of time represented
+ * as a count of seconds and fractions of seconds at nanosecond
+ * resolution. It is independent of any calendar and concepts like "day"
+ * or "month". It is related to Timestamp in that the difference between
+ * two Timestamp values is a Duration and it can be added or subtracted
+ * from a Timestamp. Range is approximately +-10,000 years.
+ *
+ * Based on google protobuf duration definition: <https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/duration.proto>
+ */
+export class Duration {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    /**
+     * Signed seconds of the span of time. Must be from -315,576,000,000
+     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+     */
+    seconds() {
+        return this.bb.readInt64(this.bb_pos);
+    }
+    /**
+     * Signed fractions of a second at nanosecond resolution of the span
+     * of time. Durations less than one second are represented with a 0
+     * `seconds` field and a positive or negative `nanos` field. For durations
+     * of one second or more, a non-zero value for the `nanos` field must be
+     * of the same sign as the `seconds` field. Must be from -999,999,999
+     * to +999,999,999 inclusive.
+     */
+    nanos() {
+        return this.bb.readInt32(this.bb_pos + 8);
+    }
+    static sizeOf() {
+        return 16;
+    }
+    static createDuration(builder, seconds, nanos) {
+        builder.prep(8, 16);
+        builder.pad(4);
+        builder.writeInt32(nanos);
+        builder.writeInt64(BigInt(seconds ?? 0));
+        return builder.offset();
+    }
+    unpack() {
+        return new DurationT(this.seconds(), this.nanos());
+    }
+    unpackTo(_o) {
+        _o.seconds = this.seconds();
+        _o.nanos = this.nanos();
+    }
+}
+export class DurationT {
+    constructor(seconds = BigInt('0'), nanos = 0) {
+        this.seconds = seconds;
+        this.nanos = nanos;
+    }
+    pack(builder) {
+        return Duration.createDuration(builder, this.seconds, this.nanos);
+    }
+}

package/lib/fbs/weidmueller/ucontrol/hub/provider-definition-changed-event.js

@@ -0,0 +1,69 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { ProviderDefinition } from '../../../weidmueller/ucontrol/hub/provider-definition.js';
+/**
+ * An event that describes a provider's definition that has just changed.
+ */
+export class ProviderDefinitionChangedEvent {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsProviderDefinitionChangedEvent(bb, obj) {
+        return (obj || new ProviderDefinitionChangedEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsProviderDefinitionChangedEvent(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new ProviderDefinitionChangedEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    /**
+     * A definition that has just been changed.
+     * If the provider_definition is null, the provider is removed.
+     */
+    providerDefinition(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new ProviderDefinition()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startProviderDefinitionChangedEvent(builder) {
+        builder.startObject(1);
+    }
+    static addProviderDefinition(builder, providerDefinitionOffset) {
+        builder.addFieldOffset(0, providerDefinitionOffset, 0);
+    }
+    static endProviderDefinitionChangedEvent(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static finishProviderDefinitionChangedEventBuffer(builder, offset) {
+        builder.finish(offset);
+    }
+    static finishSizePrefixedProviderDefinitionChangedEventBuffer(builder, offset) {
+        builder.finish(offset, undefined, true);
+    }
+    static createProviderDefinitionChangedEvent(builder, providerDefinitionOffset) {
+        ProviderDefinitionChangedEvent.startProviderDefinitionChangedEvent(builder);
+        ProviderDefinitionChangedEvent.addProviderDefinition(builder, providerDefinitionOffset);
+        return ProviderDefinitionChangedEvent.endProviderDefinitionChangedEvent(builder);
+    }
+    unpack() {
+        return new ProviderDefinitionChangedEventT((this.providerDefinition() !== null ? this.providerDefinition().unpack() : null));
+    }
+    unpackTo(_o) {
+        _o.providerDefinition = (this.providerDefinition() !== null ? this.providerDefinition().unpack() : null);
+    }
+}
+export class ProviderDefinitionChangedEventT {
+    constructor(providerDefinition = null) {
+        this.providerDefinition = providerDefinition;
+    }
+    pack(builder) {
+        const providerDefinition = (this.providerDefinition !== null ? this.providerDefinition.pack(builder) : 0);
+        return ProviderDefinitionChangedEvent.createProviderDefinitionChangedEvent(builder, providerDefinition);
+    }
+}

package/lib/fbs/weidmueller/ucontrol/hub/provider-definition-state.js

@@ -0,0 +1,20 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+/**
+ * The state of the provider definition. The state will be set by the registry.
+ */
+export var ProviderDefinitionState;
+(function (ProviderDefinitionState) {
+    /**
+     * The state is unspecified.
+     */
+    ProviderDefinitionState[ProviderDefinitionState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * The provider definition is ok and valid.
+     */
+    ProviderDefinitionState[ProviderDefinitionState["OK"] = 1] = "OK";
+    /**
+     * The provider definition is invalid => variable_definitions.size = 0
+     */
+    ProviderDefinitionState[ProviderDefinitionState["INVALID"] = 2] = "INVALID";
+})(ProviderDefinitionState || (ProviderDefinitionState = {}));

package/lib/fbs/weidmueller/ucontrol/hub/provider-definition.js

@@ -0,0 +1,118 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { ProviderDefinitionState } from '../../../weidmueller/ucontrol/hub/provider-definition-state.js';
+import { VariableDefinition } from '../../../weidmueller/ucontrol/hub/variable-definition.js';
+/**
+ * A definition of a provider's provided variables.
+ *
+ * Definition elements have a flat list instead of a hierarchy structure.
+ * They support the folder concept as a means of grouping definitions by using
+ * a shared key prefix for the grouped definitions.
+ * This means that the grouped definitions have keys that begin with a common
+ * string.
+ * This common string, or shared prefix, is the folder key.
+ *
+ * For security reasons, the provider id must be extracted from the
+ * communication channel.
+ */
+export class ProviderDefinition {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsProviderDefinition(bb, obj) {
+        return (obj || new ProviderDefinition()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsProviderDefinition(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new ProviderDefinition()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    /**
+     * The fingerprint is a version identification of the provider definition.
+     *
+     * Therefore, the fingerprint can be used by a consumer to check whether
+     * the provider's definition matches the values received.
+     * Whenever a provider definition changed, the provider must change the
+     * fingerprint.
+     */
+    fingerprint() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt('0');
+    }
+    /**
+     * The list of variable definitions.
+     */
+    variableDefinitions(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new VariableDefinition()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    variableDefinitionsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    /**
+     * The current state of the provider definition. The state will be set by the registry.
+     */
+    state() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : ProviderDefinitionState.UNSPECIFIED;
+    }
+    static startProviderDefinition(builder) {
+        builder.startObject(3);
+    }
+    static addFingerprint(builder, fingerprint) {
+        builder.addFieldInt64(0, fingerprint, BigInt('0'));
+    }
+    static addVariableDefinitions(builder, variableDefinitionsOffset) {
+        builder.addFieldOffset(1, variableDefinitionsOffset, 0);
+    }
+    static createVariableDefinitionsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startVariableDefinitionsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addState(builder, state) {
+        builder.addFieldInt8(2, state, ProviderDefinitionState.UNSPECIFIED);
+    }
+    static endProviderDefinition(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createProviderDefinition(builder, fingerprint, variableDefinitionsOffset, state) {
+        ProviderDefinition.startProviderDefinition(builder);
+        ProviderDefinition.addFingerprint(builder, fingerprint);
+        ProviderDefinition.addVariableDefinitions(builder, variableDefinitionsOffset);
+        ProviderDefinition.addState(builder, state);
+        return ProviderDefinition.endProviderDefinition(builder);
+    }
+    unpack() {
+        return new ProviderDefinitionT(this.fingerprint(), this.bb.createObjList(this.variableDefinitions.bind(this), this.variableDefinitionsLength()), this.state());
+    }
+    unpackTo(_o) {
+        _o.fingerprint = this.fingerprint();
+        _o.variableDefinitions = this.bb.createObjList(this.variableDefinitions.bind(this), this.variableDefinitionsLength());
+        _o.state = this.state();
+    }
+}
+export class ProviderDefinitionT {
+    constructor(fingerprint = BigInt('0'), variableDefinitions = [], state = ProviderDefinitionState.UNSPECIFIED) {
+        this.fingerprint = fingerprint;
+        this.variableDefinitions = variableDefinitions;
+        this.state = state;
+    }
+    pack(builder) {
+        const variableDefinitions = ProviderDefinition.createVariableDefinitionsVector(builder, builder.createObjectOffsetList(this.variableDefinitions));
+        return ProviderDefinition.createProviderDefinition(builder, this.fingerprint, variableDefinitions, this.state);
+    }
+}

package/lib/fbs/weidmueller/ucontrol/hub/provider-list.js

@@ -0,0 +1,76 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { Provider } from '../../../weidmueller/ucontrol/hub/provider.js';
+/**
+ * A list of providers that provide variables to consumers.
+ */
+export class ProviderList {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsProviderList(bb, obj) {
+        return (obj || new ProviderList()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsProviderList(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new ProviderList()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    /**
+     * The list of providers.
+     */
+    items(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new Provider()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    itemsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    static startProviderList(builder) {
+        builder.startObject(1);
+    }
+    static addItems(builder, itemsOffset) {
+        builder.addFieldOffset(0, itemsOffset, 0);
+    }
+    static createItemsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startItemsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static endProviderList(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createProviderList(builder, itemsOffset) {
+        ProviderList.startProviderList(builder);
+        ProviderList.addItems(builder, itemsOffset);
+        return ProviderList.endProviderList(builder);
+    }
+    unpack() {
+        return new ProviderListT(this.bb.createObjList(this.items.bind(this), this.itemsLength()));
+    }
+    unpackTo(_o) {
+        _o.items = this.bb.createObjList(this.items.bind(this), this.itemsLength());
+    }
+}
+export class ProviderListT {
+    constructor(items = []) {
+        this.items = items;
+    }
+    pack(builder) {
+        const items = ProviderList.createItemsVector(builder, builder.createObjectOffsetList(this.items));
+        return ProviderList.createProviderList(builder, items);
+    }
+}

package/lib/fbs/weidmueller/ucontrol/hub/provider.js

@@ -0,0 +1,59 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+/**
+ * A provider that provides variables to consumers.
+ */
+export class Provider {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsProvider(bb, obj) {
+        return (obj || new Provider()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsProvider(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new Provider()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    id(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    static startProvider(builder) {
+        builder.startObject(1);
+    }
+    static addId(builder, idOffset) {
+        builder.addFieldOffset(0, idOffset, 0);
+    }
+    static endProvider(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4); // id
+        return offset;
+    }
+    static createProvider(builder, idOffset) {
+        Provider.startProvider(builder);
+        Provider.addId(builder, idOffset);
+        return Provider.endProvider(builder);
+    }
+    unpack() {
+        return new ProviderT(this.id());
+    }
+    unpackTo(_o) {
+        _o.id = this.id();
+    }
+}
+export class ProviderT {
+    constructor(id = null) {
+        this.id = id;
+    }
+    pack(builder) {
+        const id = (this.id !== null ? builder.createString(this.id) : 0);
+        return Provider.createProvider(builder, id);
+    }
+}