node-red-contrib-uos-nats 0.1.0

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

@@ -0,0 +1,131 @@
+// 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 { Timestamp } from '../../../weidmueller/ucontrol/hub/timestamp.js';
+import { VariableQuality } from '../../../weidmueller/ucontrol/hub/variable-quality.js';
+import { VariableValue, unionToVariableValue } from '../../../weidmueller/ucontrol/hub/variable-value.js';
+/**
+ * A variable associated with the provider's definition.
+ */
+export class Variable {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsVariable(bb, obj) {
+        return (obj || new Variable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsVariable(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new Variable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    valueType() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : VariableValue.NONE;
+    }
+    /**
+     * The value of the variable.
+     */
+    value(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
+    }
+    /**
+     * The ID of the variable associated with the provider's definition.
+     */
+    id() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+    }
+    /**
+     * The individual timestamp of the variable.
+     *
+     * Only set by the provider!
+     * Consumers can left this empty. This value is ignored by the provider in
+     * a write command.
+     */
+    timestamp(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? (obj || new Timestamp()).__init(this.bb_pos + offset, this.bb) : null;
+    }
+    /**
+     * The quality of the variable.
+     *
+     * Only set by the provider!
+     * Consumers can set it to BAD. This value is ignored by the provider
+     * in a write command.
+     */
+    quality() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : VariableQuality.BAD;
+    }
+    static startVariable(builder) {
+        builder.startObject(5);
+    }
+    static addValueType(builder, valueType) {
+        builder.addFieldInt8(0, valueType, VariableValue.NONE);
+    }
+    static addValue(builder, valueOffset) {
+        builder.addFieldOffset(1, valueOffset, 0);
+    }
+    static addId(builder, id) {
+        builder.addFieldInt32(2, id, 0);
+    }
+    static addTimestamp(builder, timestampOffset) {
+        builder.addFieldStruct(3, timestampOffset, 0);
+    }
+    static addQuality(builder, quality) {
+        builder.addFieldInt8(4, quality, VariableQuality.BAD);
+    }
+    static endVariable(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 6); // value
+        return offset;
+    }
+    unpack() {
+        return new VariableT(this.valueType(), (() => {
+            const temp = unionToVariableValue(this.valueType(), this.value.bind(this));
+            if (temp === null) {
+                return null;
+            }
+            return temp.unpack();
+        })(), this.id(), (this.timestamp() !== null ? this.timestamp().unpack() : null), this.quality());
+    }
+    unpackTo(_o) {
+        _o.valueType = this.valueType();
+        _o.value = (() => {
+            const temp = unionToVariableValue(this.valueType(), this.value.bind(this));
+            if (temp === null) {
+                return null;
+            }
+            return temp.unpack();
+        })();
+        _o.id = this.id();
+        _o.timestamp = (this.timestamp() !== null ? this.timestamp().unpack() : null);
+        _o.quality = this.quality();
+    }
+}
+export class VariableT {
+    constructor(valueType = VariableValue.NONE, value = null, id = 0, timestamp = null, quality = VariableQuality.BAD) {
+        this.valueType = valueType;
+        this.value = value;
+        this.id = id;
+        this.timestamp = timestamp;
+        this.quality = quality;
+    }
+    pack(builder) {
+        const value = builder.createObjectOffset(this.value);
+        Variable.startVariable(builder);
+        Variable.addValueType(builder, this.valueType);
+        Variable.addValue(builder, value);
+        Variable.addId(builder, this.id);
+        Variable.addTimestamp(builder, (this.timestamp !== null ? this.timestamp.pack(builder) : 0));
+        Variable.addQuality(builder, this.quality);
+        return Variable.endVariable(builder);
+    }
+}

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

@@ -0,0 +1,71 @@
+// 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 { VariableList } from '../../../weidmueller/ucontrol/hub/variable-list.js';
+/**
+ * An event that describes a provider's list of variables that have just
+ * changed.
+ */
+export class VariablesChangedEvent {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsVariablesChangedEvent(bb, obj) {
+        return (obj || new VariablesChangedEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsVariablesChangedEvent(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new VariablesChangedEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    /**
+     * A list of variables that have just been changed.
+     * Only contains changed variables!
+     */
+    changedVariables(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new VariableList()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startVariablesChangedEvent(builder) {
+        builder.startObject(1);
+    }
+    static addChangedVariables(builder, changedVariablesOffset) {
+        builder.addFieldOffset(0, changedVariablesOffset, 0);
+    }
+    static endVariablesChangedEvent(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4); // changed_variables
+        return offset;
+    }
+    static finishVariablesChangedEventBuffer(builder, offset) {
+        builder.finish(offset);
+    }
+    static finishSizePrefixedVariablesChangedEventBuffer(builder, offset) {
+        builder.finish(offset, undefined, true);
+    }
+    static createVariablesChangedEvent(builder, changedVariablesOffset) {
+        VariablesChangedEvent.startVariablesChangedEvent(builder);
+        VariablesChangedEvent.addChangedVariables(builder, changedVariablesOffset);
+        return VariablesChangedEvent.endVariablesChangedEvent(builder);
+    }
+    unpack() {
+        return new VariablesChangedEventT((this.changedVariables() !== null ? this.changedVariables().unpack() : null));
+    }
+    unpackTo(_o) {
+        _o.changedVariables = (this.changedVariables() !== null ? this.changedVariables().unpack() : null);
+    }
+}
+export class VariablesChangedEventT {
+    constructor(changedVariables = null) {
+        this.changedVariables = changedVariables;
+    }
+    pack(builder) {
+        const changedVariables = (this.changedVariables !== null ? this.changedVariables.pack(builder) : 0);
+        return VariablesChangedEvent.createVariablesChangedEvent(builder, changedVariables);
+    }
+}

package/lib/fbs/weidmueller/ucontrol/hub/write-variables-command.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 { VariableList } from '../../../weidmueller/ucontrol/hub/variable-list.js';
+/**
+ * A command writing a list of provider variables.
+ */
+export class WriteVariablesCommand {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsWriteVariablesCommand(bb, obj) {
+        return (obj || new WriteVariablesCommand()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsWriteVariablesCommand(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new WriteVariablesCommand()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    /**
+     * A list of variables that have to be written.
+     */
+    variables(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new VariableList()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startWriteVariablesCommand(builder) {
+        builder.startObject(1);
+    }
+    static addVariables(builder, variablesOffset) {
+        builder.addFieldOffset(0, variablesOffset, 0);
+    }
+    static endWriteVariablesCommand(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4); // variables
+        return offset;
+    }
+    static finishWriteVariablesCommandBuffer(builder, offset) {
+        builder.finish(offset);
+    }
+    static finishSizePrefixedWriteVariablesCommandBuffer(builder, offset) {
+        builder.finish(offset, undefined, true);
+    }
+    static createWriteVariablesCommand(builder, variablesOffset) {
+        WriteVariablesCommand.startWriteVariablesCommand(builder);
+        WriteVariablesCommand.addVariables(builder, variablesOffset);
+        return WriteVariablesCommand.endWriteVariablesCommand(builder);
+    }
+    unpack() {
+        return new WriteVariablesCommandT((this.variables() !== null ? this.variables().unpack() : null));
+    }
+    unpackTo(_o) {
+        _o.variables = (this.variables() !== null ? this.variables().unpack() : null);
+    }
+}
+export class WriteVariablesCommandT {
+    constructor(variables = null) {
+        this.variables = variables;
+    }
+    pack(builder) {
+        const variables = (this.variables !== null ? this.variables.pack(builder) : 0);
+        return WriteVariablesCommand.createWriteVariablesCommand(builder, variables);
+    }
+}

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

@@ -0,0 +1,17 @@
+// 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 */
+export { Duration, DurationT } from './hub/duration.js';
+export { Timestamp, TimestampT } from './hub/timestamp.js';
+export { Variable, VariableT } from './hub/variable.js';
+export { VariableAccessType } from './hub/variable-access-type.js';
+export { VariableDataType } from './hub/variable-data-type.js';
+export { VariableDefinition, VariableDefinitionT } from './hub/variable-definition.js';
+export { VariableList, VariableListT } from './hub/variable-list.js';
+export { VariableQuality } from './hub/variable-quality.js';
+export { VariableValue } from './hub/variable-value.js';
+export { VariableValueBoolean, VariableValueBooleanT } from './hub/variable-value-boolean.js';
+export { VariableValueDuration, VariableValueDurationT } from './hub/variable-value-duration.js';
+export { VariableValueFloat64, VariableValueFloat64T } from './hub/variable-value-float64.js';
+export { VariableValueInt64, VariableValueInt64T } from './hub/variable-value-int64.js';
+export { VariableValueString, VariableValueStringT } from './hub/variable-value-string.js';
+export { VariableValueTimestamp, VariableValueTimestampT } from './hub/variable-value-timestamp.js';

package/lib/models.js

@@ -0,0 +1 @@
+export {};

package/lib/payloads.js

@@ -0,0 +1,182 @@
+import { createHash } from 'node:crypto';
+import * as flatbuffers from 'flatbuffers';
+import { ProviderDefinitionChangedEventT } from './fbs/weidmueller/ucontrol/hub/provider-definition-changed-event.js';
+import { ProviderDefinitionT } from './fbs/weidmueller/ucontrol/hub/provider-definition.js';
+import { VariableDefinitionT } from './fbs/weidmueller/ucontrol/hub/variable-definition.js';
+import { VariableAccessType } from './fbs/weidmueller/ucontrol/hub/variable-access-type.js';
+import { VariableDataType } from './fbs/weidmueller/ucontrol/hub/variable-data-type.js';
+import { VariablesChangedEventT } from './fbs/weidmueller/ucontrol/hub/variables-changed-event.js';
+import { VariableListT } from './fbs/weidmueller/ucontrol/hub/variable-list.js';
+import { VariableT } from './fbs/weidmueller/ucontrol/hub/variable.js';
+import { VariableQuality } from './fbs/weidmueller/ucontrol/hub/variable-quality.js';
+import { VariableValue } from './fbs/weidmueller/ucontrol/hub/variable-value.js';
+import { VariableValueInt64, VariableValueInt64T } from './fbs/weidmueller/ucontrol/hub/variable-value-int64.js';
+import { VariableValueFloat64, VariableValueFloat64T } from './fbs/weidmueller/ucontrol/hub/variable-value-float64.js';
+import { VariableValueString, VariableValueStringT } from './fbs/weidmueller/ucontrol/hub/variable-value-string.js';
+import { VariableValueBoolean, VariableValueBooleanT } from './fbs/weidmueller/ucontrol/hub/variable-value-boolean.js';
+import { TimestampT } from './fbs/weidmueller/ucontrol/hub/timestamp.js';
+import { ReadVariablesQueryResponseT } from './fbs/weidmueller/ucontrol/hub/read-variables-query-response.js';
+import { ReadVariablesQueryRequestT } from './fbs/weidmueller/ucontrol/hub/read-variables-query-request.js';
+const DEFAULT_QUALITY = 'GOOD';
+export function buildProviderDefinitionEvent(defs) {
+    const fingerprint = computeFingerprint(defs);
+    const providerDefinition = new ProviderDefinitionT();
+    providerDefinition.fingerprint = fingerprint;
+    providerDefinition.variableDefinitions = defs.map(toFlatDefinition);
+    const event = new ProviderDefinitionChangedEventT(providerDefinition);
+    const builder = new flatbuffers.Builder(1024);
+    const offset = event.pack(builder);
+    builder.finish(offset);
+    return { payload: builder.asUint8Array(), fingerprint };
+}
+export function buildVariablesChangedEvent(defs, states, fingerprint) {
+    const varList = buildVariableList(defs, states, fingerprint);
+    const event = new VariablesChangedEventT(varList);
+    const builder = new flatbuffers.Builder(1024);
+    builder.finish(event.pack(builder));
+    return builder.asUint8Array();
+}
+export function buildReadVariablesResponse(defs, states, fingerprint) {
+    const varList = buildVariableList(defs, states, fingerprint);
+    const response = new ReadVariablesQueryResponseT(varList);
+    const builder = new flatbuffers.Builder(1024);
+    builder.finish(response.pack(builder));
+    return builder.asUint8Array();
+}
+export function buildReadVariablesQuery(ids) {
+    const query = new ReadVariablesQueryRequestT(ids ?? []);
+    const builder = new flatbuffers.Builder(128);
+    builder.finish(query.pack(builder));
+    return builder.asUint8Array();
+}
+export function decodeVariableList(list) {
+    if (!list)
+        return [];
+    const result = [];
+    for (let i = 0; i < list.itemsLength(); i += 1) {
+        const item = list.items(i);
+        if (!item)
+            continue;
+        let decoded;
+        switch (item.valueType()) {
+            case VariableValue.Int64: {
+                const holder = new VariableValueInt64();
+                item.value(holder);
+                decoded = Number(holder.value());
+                break;
+            }
+            case VariableValue.Float64: {
+                const holder = new VariableValueFloat64();
+                item.value(holder);
+                decoded = holder.value();
+                break;
+            }
+            case VariableValue.Boolean: {
+                const holder = new VariableValueBoolean();
+                item.value(holder);
+                decoded = !!holder.value();
+                break;
+            }
+            case VariableValue.String:
+            default: {
+                const holder = new VariableValueString();
+                item.value(holder);
+                decoded = holder.value()?.toString() ?? '';
+                break;
+            }
+        }
+        const ts = item.timestamp();
+        const seconds = ts ? Number(ts.seconds()) : 0;
+        const nanos = ts ? ts.nanos() : 0;
+        result.push({
+            id: item.id(),
+            value: decoded,
+            timestampNs: seconds * 1000000000 + nanos,
+            quality: DEFAULT_QUALITY,
+        });
+    }
+    return result;
+}
+function toFlatDefinition(def) {
+    const result = new VariableDefinitionT();
+    result.id = def.id;
+    result.key = def.key;
+    result.experimental = Boolean(def.experimental);
+    result.dataType = mapDataType(def.dataType);
+    result.accessType = def.access === 'READ_WRITE' ? VariableAccessType.READ_WRITE : VariableAccessType.READ_ONLY;
+    return result;
+}
+function buildVariableList(defs, states, fingerprint) {
+    const statesMap = new Map(states.map((s) => [s.id, s]));
+    const items = [];
+    for (const def of defs) {
+        const state = statesMap.get(def.id);
+        if (!state)
+            continue;
+        const variable = new VariableT();
+        variable.id = def.id;
+        const [valueType, value] = toValueUnion(def.dataType, state.value);
+        variable.valueType = valueType;
+        variable.value = value;
+        variable.timestamp = toTimestamp(state.timestampNs);
+        variable.quality = VariableQuality.GOOD;
+        items.push(variable);
+    }
+    const list = new VariableListT();
+    list.providerDefinitionFingerprint = fingerprint;
+    list.baseTimestamp = items.length ? (items[0].timestamp ?? toTimestamp(Date.now() * 1000000)) : toTimestamp(Date.now() * 1000000);
+    list.items = items;
+    return list;
+}
+function toTimestamp(ns) {
+    const ts = new TimestampT();
+    ts.seconds = BigInt(Math.floor(ns / 1000000000));
+    ts.nanos = ns % 1000000000;
+    return ts;
+}
+function toValueUnion(type, value) {
+    switch (type) {
+        case 'INT64': {
+            const holder = new VariableValueInt64T();
+            holder.value = BigInt(Math.trunc(Number(value)));
+            return [VariableValue.Int64, holder];
+        }
+        case 'FLOAT64': {
+            const holder = new VariableValueFloat64T();
+            holder.value = Number(value);
+            return [VariableValue.Float64, holder];
+        }
+        case 'BOOLEAN': {
+            const holder = new VariableValueBooleanT();
+            holder.value = Boolean(value);
+            return [VariableValue.Boolean, holder];
+        }
+        case 'STRING':
+        default: {
+            const holder = new VariableValueStringT();
+            holder.value = String(value);
+            return [VariableValue.String, holder];
+        }
+    }
+}
+function mapDataType(type) {
+    switch (type) {
+        case 'INT64':
+            return VariableDataType.INT64;
+        case 'FLOAT64':
+            return VariableDataType.FLOAT64;
+        case 'BOOLEAN':
+            return VariableDataType.BOOLEAN;
+        case 'STRING':
+        default:
+            return VariableDataType.STRING;
+    }
+}
+function computeFingerprint(defs) {
+    const hash = createHash('sha256');
+    for (const def of [...defs].sort((a, b) => a.id - b.id)) {
+        hash.update(`${def.id}:${def.key}:${def.dataType}:${def.access}:${def.experimental ?? false}`);
+    }
+    const digest = hash.digest();
+    return digest.readBigUInt64BE(0);
+}

package/lib/provider.js

@@ -0,0 +1,51 @@
+import { connect } from 'nats';
+import { requestToken } from './auth.js';
+import { CLIENT_NAME, NATS_SERVER, PROVIDER_ID, PUBLISH_INTERVAL_MS, VARIABLE_DEFINITIONS, } from './config.js';
+import { SimulationEngine } from './simulation.js';
+import { buildProviderDefinitionEvent, buildReadVariablesResponse, buildVariablesChangedEvent, } from './payloads.js';
+import { providerDefinitionChanged, readVariablesQuery, varsChangedEvent } from './subjects.js';
+async function main() {
+    console.log(`[provider] Node Provider für ${PROVIDER_ID} wird gestartet…`);
+    const token = await requestToken();
+    const nc = await connect({
+        servers: NATS_SERVER.split(','),
+        token,
+        name: `${CLIENT_NAME}-node-provider`,
+        inboxPrefix: `_INBOX.${CLIENT_NAME}`,
+    });
+    console.log('[provider] NATS verbunden:', nc.getServer());
+    const simulation = new SimulationEngine(VARIABLE_DEFINITIONS);
+    const { payload: definitionPayload, fingerprint } = buildProviderDefinitionEvent(VARIABLE_DEFINITIONS);
+    await nc.publish(providerDefinitionChanged(PROVIDER_ID), definitionPayload);
+    const readSubject = readVariablesQuery(PROVIDER_ID);
+    const sub = nc.subscribe(readSubject, {
+        callback: async (err, msg) => {
+            if (err) {
+                console.error('[provider] Fehler beim Read-Subscribe', err);
+                return;
+            }
+            if (!msg.reply)
+                return;
+            const responsePayload = buildReadVariablesResponse(VARIABLE_DEFINITIONS, simulation.snapshot(), fingerprint);
+            await nc.publish(msg.reply, responsePayload);
+        },
+    });
+    const timer = setInterval(async () => {
+        const states = simulation.advance();
+        const payload = buildVariablesChangedEvent(VARIABLE_DEFINITIONS, states, fingerprint);
+        await nc.publish(varsChangedEvent(PROVIDER_ID), payload);
+    }, PUBLISH_INTERVAL_MS);
+    const shutdown = async () => {
+        clearInterval(timer);
+        sub.drain();
+        await nc.drain();
+        console.log('[provider] Verbindung geschlossen');
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((err) => {
+    console.error('[provider] Fehler:', err);
+    process.exit(1);
+});

package/lib/simulation.js

@@ -0,0 +1,54 @@
+export class SimulationEngine {
+    constructor(definitions) {
+        this.definitions = definitions;
+        this.tick = 0;
+        this.states = new Map(definitions.map((def) => [def.id, {
+                id: def.id,
+                value: this.initialValue(def),
+                timestampNs: Date.now() * 1000000,
+                quality: 'GOOD',
+            }]));
+    }
+    initialValue(def) {
+        switch (def.dataType) {
+            case 'INT64':
+                return 0;
+            case 'FLOAT64':
+                return 0;
+            case 'BOOLEAN':
+                return false;
+            case 'STRING':
+            default:
+                return def.key.includes('status') ? 'ready' : '';
+        }
+    }
+    advance() {
+        this.tick += 1;
+        const nowNs = Date.now() * 1000000;
+        for (const def of this.definitions) {
+            const state = this.states.get(def.id);
+            state.timestampNs = nowNs;
+            switch (def.dataType) {
+                case 'INT64':
+                    state.value = Number(state.value) + 1;
+                    break;
+                case 'FLOAT64':
+                    state.value = Number((20 + Math.sin(this.tick / 5) * 5).toFixed(3));
+                    break;
+                case 'STRING':
+                    if (def.key.includes('status')) {
+                        const values = ['ready', 'running', 'idle'];
+                        state.value = values[this.tick % values.length];
+                    }
+                    break;
+                case 'BOOLEAN':
+                    state.value = !Boolean(state.value);
+                    break;
+            }
+        }
+        return Array.from(this.states.values());
+    }
+    snapshot() {
+        return Array.from(this.states.values());
+    }
+}

package/lib/subjects.js

@@ -0,0 +1,11 @@
+const VERSION_PREFIX = 'v1';
+const LOCATION_PREFIX = 'loc';
+export function varsChangedEvent(providerId) {
+    return `${VERSION_PREFIX}.${LOCATION_PREFIX}.${providerId}.vars.evt.changed`;
+}
+export function readVariablesQuery(providerId) {
+    return `${VERSION_PREFIX}.${LOCATION_PREFIX}.${providerId}.vars.qry.read`;
+}
+export function providerDefinitionChanged(providerId) {
+    return `${VERSION_PREFIX}.${LOCATION_PREFIX}.${providerId}.def.evt.changed`;
+}