matterbridge-example-dynamic-platform 1.1.8 → 1.2.0-edge.3

package/dist/appliances.js

@@ -0,0 +1,351 @@
+import { DeviceClasses, DeviceTypeDefinition, MatterbridgeEndpoint, Status, Matterbridge, VendorId, DeviceTypeId, MatterbridgeServer, smokeCoAlarm, } from 'matterbridge';
+import { ClusterBehavior, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint } from 'matterbridge/matter';
+import { Identify, OperationalState, OnOff, TemperatureControl, DishwasherAlarm, DishwasherMode, LaundryWasherControls, LaundryWasherMode, TemperatureMeasurement, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, } from 'matterbridge/matter/clusters';
+import { DishwasherAlarmServer, OperationalStateBehavior, TemperatureControlBehavior } from 'matterbridge/matter/behaviors';
+import { OvenCavityOperationalState } from './implementations/ovenCavityOperationalStateCluster.js';
+import { AnsiLogger } from 'matterbridge/logger';
+import { Robot } from './robot.js';
+export class Appliances extends MatterbridgeEndpoint {
+    static temperatureControlledCabinetCooler = DeviceTypeDefinition({
+        name: 'MA-temperaturecontrolledcabinetcooler',
+        code: 0x71,
+        deviceClass: DeviceClasses.Simple,
+        revision: 3,
+        requiredServerClusters: [TemperatureControl.Cluster.id, RefrigeratorAndTemperatureControlledCabinetMode.Cluster.id],
+        optionalServerClusters: [TemperatureMeasurement.Cluster.id],
+    });
+    static temperatureControlledCabinetHeater = DeviceTypeDefinition({
+        name: 'MA-temperaturecontrolledcabinetheater',
+        code: 0x71,
+        deviceClass: DeviceClasses.Simple,
+        revision: 3,
+        requiredServerClusters: [TemperatureControl.Cluster.id, OvenMode.Cluster.id, OvenCavityOperationalState.Cluster.id],
+        optionalServerClusters: [TemperatureMeasurement.Cluster.id],
+    });
+    static laundryWasher = DeviceTypeDefinition({
+        name: 'MA-laundrywasher',
+        code: 0x73,
+        deviceClass: DeviceClasses.Simple,
+        revision: 1,
+        requiredServerClusters: [OperationalState.Cluster.id],
+        optionalServerClusters: [Identify.Cluster.id, LaundryWasherMode.Cluster.id, OnOff.Cluster.id, LaundryWasherControls.Cluster.id, TemperatureControl.Cluster.id],
+    });
+    static dishwasher = DeviceTypeDefinition({
+        name: 'MA-dishwasher',
+        code: 0x75,
+        deviceClass: DeviceClasses.Simple,
+        revision: 1,
+        requiredServerClusters: [OperationalState.Cluster.id],
+        optionalServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, TemperatureControl.Cluster.id, DishwasherMode.Cluster.id, DishwasherAlarm.Cluster.id],
+    });
+    constructor(deviceType, name, serial) {
+        super(deviceType, { uniqueStorageKey: `${name}-${serial}` });
+        if (deviceType.code === Appliances.laundryWasher.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Washer');
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.code === Appliances.dishwasher.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDeadFrontOnOffClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Dishwasher');
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
+            this.createDefaultDishwasherModeClusterServer();
+            this.createDefaultDishwasherAlarmClusterServer();
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.name === Appliances.temperatureControlledCabinetCooler.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Temperature Controlled Cabinet Cooler');
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', 'Warm', 'Hot']);
+            this.createDefaultTemperatureMeasurementClusterServer(1500);
+            this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(1);
+        }
+        else if (deviceType.name === Appliances.temperatureControlledCabinetHeater.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Temperature Controlled Cabinet Heater');
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', 'Warm', 'Hot']);
+            this.createDefaultTemperatureMeasurementClusterServer(2500);
+            this.createDefaultOvenModeClusterServer(3);
+            this.createDefaultOvenCavityOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+    }
+    createDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+        this.behaviors.require(MatterbridgeOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+            ],
+            operationalState,
+            operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+    createDefaultOvenCavityOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+        this.behaviors.require(OvenCavityOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+            ],
+            operationalState,
+            operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+    createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(currentMode) {
+        this.behaviors.require(RefrigeratorAndTemperatureControlledCabinetModeServer, {
+            supportedModes: [
+                { label: 'RapidCool', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
+                { label: 'RapidFreeze', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultDishwasherModeClusterServer(currentMode) {
+        this.behaviors.require(DishwasherModeServer, {
+            supportedModes: [
+                { label: 'Light', mode: 1, modeTags: [{ value: DishwasherMode.ModeTag.Light }] },
+                { label: 'Normal', mode: 2, modeTags: [{ value: DishwasherMode.ModeTag.Normal }] },
+                { label: 'Heavy', mode: 3, modeTags: [{ value: DishwasherMode.ModeTag.Heavy }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultDishwasherAlarmClusterServer() {
+        this.behaviors.require(DishwasherAlarmServer, {
+            mask: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+            state: { inflowError: false, drainError: false, doorError: false, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
+            supported: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+        });
+        return this;
+    }
+    createDefaultOvenModeClusterServer(currentMode) {
+        this.behaviors.require(OvenModeServer, {
+            supportedModes: [
+                { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
+                { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
+                { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
+                { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
+                { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
+                { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
+                { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
+                { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
+                { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
+                { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+        this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+            selectedTemperatureLevel,
+            supportedTemperatureLevels,
+        });
+        return this;
+    }
+    createNumberTemperatureControlClusterServer(temperatureSetpoint, minTemperature, maxTemperature, step = 1) {
+        this.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+            temperatureSetpoint,
+            minTemperature,
+            maxTemperature,
+            step,
+        });
+        return this;
+    }
+}
+class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer initialized: setting operational state to Docked');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+    }
+    pause() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: pause called setting operational state to Paused and currentMode to Paused');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    stop() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped and currentMode to Idle');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    start() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: start called setting operational state to Running and currentMode to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    resume() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+class MatterbridgeLevelTemperatureControlServer extends TemperatureControlBehavior.with(TemperatureControl.Feature.TemperatureLevel) {
+    initialize() {
+        if (this.state.supportedTemperatureLevels.length >= 2) {
+            const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+            device.log.info('MatterbridgeLevelTemperatureControlServer initialized: setting selectedTemperatureLevel to 1');
+            this.state.selectedTemperatureLevel = 1;
+        }
+    }
+    setTemperature(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (request.targetTemperatureLevel && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
+            device.log.info(`MatterbridgeLevelTemperatureControlServer: setTemperature called setting selectedTemperatureLevel to ${request.targetTemperatureLevel}: ${this.state.supportedTemperatureLevels[request.targetTemperatureLevel]}`);
+            this.state.selectedTemperatureLevel = request.targetTemperatureLevel;
+        }
+        else {
+            device.log.error(`MatterbridgeLevelTemperatureControlServer: setTemperature called with invalid targetTemperatureLevel ${request.targetTemperatureLevel}`);
+        }
+    }
+}
+class MatterbridgeNumberTemperatureControlServer extends TemperatureControlBehavior.with(TemperatureControl.Feature.TemperatureNumber) {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeNumberTemperatureControlServer initialized');
+    }
+    setTemperature(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (request.targetTemperature && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
+            device.log.info(`MatterbridgeNumberTemperatureControlServer: setTemperature called setting temperatureSetpoint to ${request.targetTemperature}`);
+            this.state.temperatureSetpoint = request.targetTemperature;
+        }
+        else {
+            device.log.error(`MatterbridgeNumberTemperatureControlServer: setTemperature called with invalid targetTemperature ${request.targetTemperature}`);
+        }
+    }
+}
+export const OvenCavityOperationalStateBehavior = ClusterBehavior.withInterface().for(OvenCavityOperationalState.Cluster);
+export class OvenCavityOperationalStateServer extends OvenCavityOperationalStateBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer initialized: setting operational state to Stopped and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+    }
+    stop() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer: stop called setting operational state to Stopped and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    start() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer: start called setting operational state to Running and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+export const RefrigeratorAndTemperatureControlledCabinetModeBehavior = ClusterBehavior.withInterface().for(RefrigeratorAndTemperatureControlledCabinetMode.Cluster);
+class RefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer initialized: setting currentMode to 1');
+        this.state.currentMode = 1;
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
+            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+            this.state.currentMode = request.newMode;
+            return { status: Status.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const OvenModeBehavior = ClusterBehavior.withInterface().for(OvenMode.Cluster);
+class OvenModeServer extends OvenModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('OvenModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 3;
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
+            device.log.info(`OvenModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+            this.state.currentMode = request.newMode;
+            return { status: Status.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.info(`OvenModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const DishwasherModeBehavior = ClusterBehavior.withInterface().for(DishwasherMode.Cluster);
+class DishwasherModeServer extends DishwasherModeBehavior {
+    initialize() {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        device.log.info('DishwasherModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 3;
+    }
+    changeToMode(request) {
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
+        if (this.state.supportedModes.find((mode) => mode.mode === request.newMode)) {
+            device.log.info(`DishwasherModeServer: changeToMode called with mode ${request.newMode} = ${this.state.supportedModes[request.newMode].label}`);
+            this.state.currentMode = request.newMode;
+            return { status: Status.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.error(`DishwasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: Status.InvalidCommand, statusText: 'Invalid mode' };
+        }
+    }
+}
+if (process.argv.includes('-testRobot')) {
+    const matterbridge = await Matterbridge.loadInstance(false);
+    matterbridge.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: "debug" });
+    matterbridge.environment.vars.set('log.level', MatterLogLevel.DEBUG);
+    matterbridge.environment.vars.set('log.format', MatterLogFormat.ANSI);
+    matterbridge.environment.vars.set('path.root', 'matterstorage');
+    matterbridge.environment.vars.set('runtime.signals', true);
+    matterbridge.environment.vars.set('runtime.exitcode', true);
+    matterbridge.environment.vars.set('mdns.networkInterface', 'Wi-Fi');
+    await matterbridge.startMatterStorage();
+    const deviceType = smokeCoAlarm;
+    const context = await matterbridge.createServerNodeContext('Jest', deviceType.name, DeviceTypeId(deviceType.code), VendorId(0xfff1), 'Matterbridge', 0x8000, 'Matterbridge device');
+    const server = await matterbridge.createServerNode(context);
+    const device = new Robot('Robot Vacuum', '99914248654');
+    await server.add(device);
+    logEndpoint(EndpointServer.forEndpoint(device));
+    await matterbridge.startServerNode(server);
+    logEndpoint(EndpointServer.forEndpoint(server));
+}

package/dist/implementations/carbonMonoxideConcentrationMeasurement.js

@@ -0,0 +1,113 @@
+import { ClusterBehavior } from 'matterbridge/matter';
+import { Attribute, MutableCluster, OptionalAttribute, TlvEnum, TlvNullable, TlvUInt32, TlvFloat, FixedAttribute, BitFlag, ClusterType, ClusterRegistry, } from 'matterbridge/matter/types';
+export var CarbonMonoxideConcentrationMeasurement;
+(function (CarbonMonoxideConcentrationMeasurement) {
+    let Feature;
+    (function (Feature) {
+        Feature["NumericMeasurement"] = "NumericMeasurement";
+        Feature["LevelIndication"] = "LevelIndication";
+        Feature["MediumLevel"] = "MediumLevel";
+        Feature["CriticalLevel"] = "CriticalLevel";
+        Feature["PeakMeasurement"] = "PeakMeasurement";
+        Feature["AverageMeasurement"] = "AverageMeasurement";
+    })(Feature = CarbonMonoxideConcentrationMeasurement.Feature || (CarbonMonoxideConcentrationMeasurement.Feature = {}));
+    let MeasurementUnit;
+    (function (MeasurementUnit) {
+        MeasurementUnit[MeasurementUnit["Ppm"] = 0] = "Ppm";
+        MeasurementUnit[MeasurementUnit["Ppb"] = 1] = "Ppb";
+        MeasurementUnit[MeasurementUnit["Ppt"] = 2] = "Ppt";
+        MeasurementUnit[MeasurementUnit["Mgm3"] = 3] = "Mgm3";
+        MeasurementUnit[MeasurementUnit["Ugm3"] = 4] = "Ugm3";
+        MeasurementUnit[MeasurementUnit["Ngm3"] = 5] = "Ngm3";
+        MeasurementUnit[MeasurementUnit["Pm3"] = 6] = "Pm3";
+        MeasurementUnit[MeasurementUnit["Bqm3"] = 7] = "Bqm3";
+    })(MeasurementUnit = CarbonMonoxideConcentrationMeasurement.MeasurementUnit || (CarbonMonoxideConcentrationMeasurement.MeasurementUnit = {}));
+    let LevelValue;
+    (function (LevelValue) {
+        LevelValue[LevelValue["Unknown"] = 0] = "Unknown";
+        LevelValue[LevelValue["Low"] = 1] = "Low";
+        LevelValue[LevelValue["Medium"] = 2] = "Medium";
+        LevelValue[LevelValue["High"] = 3] = "High";
+        LevelValue[LevelValue["Critical"] = 4] = "Critical";
+    })(LevelValue = CarbonMonoxideConcentrationMeasurement.LevelValue || (CarbonMonoxideConcentrationMeasurement.LevelValue = {}));
+    let MeasurementMedium;
+    (function (MeasurementMedium) {
+        MeasurementMedium[MeasurementMedium["Air"] = 0] = "Air";
+        MeasurementMedium[MeasurementMedium["Water"] = 1] = "Water";
+        MeasurementMedium[MeasurementMedium["Soil"] = 2] = "Soil";
+    })(MeasurementMedium = CarbonMonoxideConcentrationMeasurement.MeasurementMedium || (CarbonMonoxideConcentrationMeasurement.MeasurementMedium = {}));
+    CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent = MutableCluster.Component({
+        attributes: {
+            measuredValue: Attribute(0x0, TlvNullable(TlvFloat), { default: null }),
+            minMeasuredValue: Attribute(0x1, TlvNullable(TlvFloat), { default: null }),
+            maxMeasuredValue: Attribute(0x2, TlvNullable(TlvFloat), { default: null }),
+            uncertainty: OptionalAttribute(0x7, TlvFloat),
+            measurementUnit: FixedAttribute(0x8, TlvEnum()),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent = MutableCluster.Component({
+        attributes: {
+            peakMeasuredValue: Attribute(0x3, TlvNullable(TlvFloat), { default: null }),
+            peakMeasuredValueWindow: Attribute(0x4, TlvUInt32.bound({ max: 604800 }), { default: 1 }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent = MutableCluster.Component({
+        attributes: {
+            averageMeasuredValue: Attribute(0x5, TlvNullable(TlvFloat), { default: null }),
+            averageMeasuredValueWindow: Attribute(0x6, TlvUInt32.bound({ max: 604800 }), { default: 1 }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.LevelIndicationComponent = MutableCluster.Component({
+        attributes: {
+            levelValue: Attribute(0xa, TlvEnum(), { default: LevelValue.Unknown }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.Base = MutableCluster.Component({
+        id: 0x40c,
+        name: 'CarbonMonoxideConcentrationMeasurement',
+        revision: 3,
+        features: {
+            numericMeasurement: BitFlag(0),
+            levelIndication: BitFlag(1),
+            mediumLevel: BitFlag(2),
+            criticalLevel: BitFlag(3),
+            peakMeasurement: BitFlag(4),
+            averageMeasurement: BitFlag(5),
+        },
+        attributes: {
+            measurementMedium: FixedAttribute(0x9, TlvEnum()),
+        },
+        extensions: MutableCluster.Extensions({ flags: { numericMeasurement: true }, component: CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent }, { flags: { peakMeasurement: true }, component: CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent }, { flags: { averageMeasurement: true }, component: CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent }, { flags: { levelIndication: true }, component: CarbonMonoxideConcentrationMeasurement.LevelIndicationComponent }, { flags: { mediumLevel: true, levelIndication: false }, component: false }, { flags: { criticalLevel: true, levelIndication: false }, component: false }, { flags: { peakMeasurement: true, numericMeasurement: false }, component: false }, { flags: { averageMeasurement: true, numericMeasurement: false }, component: false }, { flags: { numericMeasurement: false, levelIndication: false }, component: false }),
+    });
+    CarbonMonoxideConcentrationMeasurement.ClusterInstance = MutableCluster.ExtensibleOnly(CarbonMonoxideConcentrationMeasurement.Base);
+    CarbonMonoxideConcentrationMeasurement.Cluster = CarbonMonoxideConcentrationMeasurement.ClusterInstance;
+    const MEA = { numericMeasurement: true };
+    const PEA = { peakMeasurement: true };
+    const AVG = { averageMeasurement: true };
+    const LEV = { levelIndication: true };
+    CarbonMonoxideConcentrationMeasurement.CompleteInstance = MutableCluster({
+        id: CarbonMonoxideConcentrationMeasurement.Base.id,
+        name: CarbonMonoxideConcentrationMeasurement.Base.name,
+        revision: CarbonMonoxideConcentrationMeasurement.Base.revision,
+        features: CarbonMonoxideConcentrationMeasurement.Base.features,
+        attributes: {
+            ...CarbonMonoxideConcentrationMeasurement.Base.attributes,
+            measuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.measuredValue, { mandatoryIf: [MEA] }),
+            minMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.minMeasuredValue, { mandatoryIf: [MEA] }),
+            maxMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.maxMeasuredValue, { mandatoryIf: [MEA] }),
+            peakMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent.attributes.peakMeasuredValue, { mandatoryIf: [PEA] }),
+            peakMeasuredValueWindow: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.PeakMeasurementComponent.attributes.peakMeasuredValueWindow, { mandatoryIf: [PEA] }),
+            averageMeasuredValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent.attributes.averageMeasuredValue, { mandatoryIf: [AVG] }),
+            averageMeasuredValueWindow: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.AverageMeasurementComponent.attributes.averageMeasuredValueWindow, { mandatoryIf: [AVG] }),
+            uncertainty: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.uncertainty, { optionalIf: [MEA] }),
+            measurementUnit: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.NumericMeasurementComponent.attributes.measurementUnit, { mandatoryIf: [MEA] }),
+            levelValue: MutableCluster.AsConditional(CarbonMonoxideConcentrationMeasurement.LevelIndicationComponent.attributes.levelValue, { mandatoryIf: [LEV] }),
+        },
+    });
+    CarbonMonoxideConcentrationMeasurement.Complete = CarbonMonoxideConcentrationMeasurement.CompleteInstance;
+})(CarbonMonoxideConcentrationMeasurement || (CarbonMonoxideConcentrationMeasurement = {}));
+export const CarbonMonoxideConcentrationMeasurementCluster = CarbonMonoxideConcentrationMeasurement.Cluster;
+ClusterRegistry.register(ClusterType(CarbonMonoxideConcentrationMeasurement.Complete));
+export const CarbonMonoxideConcentrationMeasurementBehavior = ClusterBehavior.for(ClusterType(CarbonMonoxideConcentrationMeasurement.Base));
+export class CarbonMonoxideConcentrationMeasurementServer extends CarbonMonoxideConcentrationMeasurementBehavior.for(ClusterType(CarbonMonoxideConcentrationMeasurement.Base)) {
+}

package/dist/implementations/ovenCavityOperationalStateCluster.js

@@ -0,0 +1,30 @@
+import { OperationalState } from 'matterbridge/matter/clusters';
+import { Attribute, EventPriority, MutableCluster, OptionalAttribute, TlvArray, Event, TlvEnum, TlvNullable, TlvString, TlvUInt32, TlvUInt8, OptionalEvent, ClusterRegistry, TlvNoArguments, Command, } from 'matterbridge/matter/types';
+export var OvenCavityOperationalState;
+(function (OvenCavityOperationalState) {
+    OvenCavityOperationalState.ClusterInstance = MutableCluster({
+        id: 0x48,
+        name: 'OvenCavityOperationalState',
+        revision: 2,
+        attributes: {
+            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
+            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
+            countdownTime: OptionalAttribute(0x2, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
+            operationalStateList: Attribute(0x3, TlvArray(OperationalState.TlvOperationalStateStruct), { default: [] }),
+            operationalState: Attribute(0x4, TlvEnum()),
+            operationalError: Attribute(0x5, OperationalState.TlvErrorStateStruct),
+        },
+        commands: {
+            stop: Command(0x1, TlvNoArguments, 0x4, OperationalState.TlvOperationalCommandResponse),
+            start: Command(0x2, TlvNoArguments, 0x4, OperationalState.TlvOperationalCommandResponse),
+        },
+        events: {
+            operationalError: Event(0x0, EventPriority.Critical, OperationalState.TlvOperationalErrorEvent),
+            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalState.TlvOperationCompletionEvent),
+        },
+    });
+    OvenCavityOperationalState.Cluster = OvenCavityOperationalState.ClusterInstance;
+    OvenCavityOperationalState.Complete = OvenCavityOperationalState.Cluster;
+})(OvenCavityOperationalState || (OvenCavityOperationalState = {}));
+export const OvenCavityOperationalStateCluster = OvenCavityOperationalState.Cluster;
+ClusterRegistry.register(OvenCavityOperationalState.Complete);

package/dist/implementations/roboticVacuumCleanerClusters.js

@@ -0,0 +1,71 @@
+import { OperationalState as OperationalStateNamespace } from 'matterbridge/matter/clusters';
+import { Attribute, ClusterRegistry, Event, EventPriority, MutableCluster, OptionalAttribute, OptionalCommand, OptionalEvent, TlvArray, TlvEnum, TlvField, TlvNoArguments, TlvNullable, TlvObject, TlvOptionalField, TlvString, TlvUInt32, TlvUInt8, } from 'matterbridge/matter/types';
+export var RvcOperationalState;
+(function (RvcOperationalState) {
+    let OperationalState;
+    (function (OperationalState) {
+        OperationalState[OperationalState["Stopped"] = 0] = "Stopped";
+        OperationalState[OperationalState["Running"] = 1] = "Running";
+        OperationalState[OperationalState["Paused"] = 2] = "Paused";
+        OperationalState[OperationalState["Error"] = 3] = "Error";
+        OperationalState[OperationalState["SeekingCharger"] = 64] = "SeekingCharger";
+        OperationalState[OperationalState["Charging"] = 65] = "Charging";
+        OperationalState[OperationalState["Docked"] = 66] = "Docked";
+    })(OperationalState = RvcOperationalState.OperationalState || (RvcOperationalState.OperationalState = {}));
+    RvcOperationalState.TlvOperationalStateStruct = TlvObject({
+        operationalStateId: TlvField(0, TlvEnum()),
+        operationalStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
+    });
+    let ErrorState;
+    (function (ErrorState) {
+        ErrorState[ErrorState["NoError"] = 0] = "NoError";
+        ErrorState[ErrorState["UnableToStartOrResume"] = 1] = "UnableToStartOrResume";
+        ErrorState[ErrorState["UnableToCompleteOperation"] = 2] = "UnableToCompleteOperation";
+        ErrorState[ErrorState["CommandInvalidInState"] = 3] = "CommandInvalidInState";
+        ErrorState[ErrorState["FailedToFindChargingDock"] = 64] = "FailedToFindChargingDock";
+        ErrorState[ErrorState["Stuck"] = 65] = "Stuck";
+        ErrorState[ErrorState["DustBinMissing"] = 66] = "DustBinMissing";
+        ErrorState[ErrorState["DustBinFull"] = 67] = "DustBinFull";
+        ErrorState[ErrorState["WaterTankEmpty"] = 68] = "WaterTankEmpty";
+        ErrorState[ErrorState["WaterTankMissing"] = 69] = "WaterTankMissing";
+        ErrorState[ErrorState["WaterTankLidOpen"] = 70] = "WaterTankLidOpen";
+        ErrorState[ErrorState["MopCleaningPadMissing"] = 71] = "MopCleaningPadMissing";
+    })(ErrorState = RvcOperationalState.ErrorState || (RvcOperationalState.ErrorState = {}));
+    RvcOperationalState.TlvErrorStateStruct = TlvObject({
+        errorStateId: TlvField(0, TlvEnum()),
+        errorStateLabel: TlvOptionalField(1, TlvString.bound({ maxLength: 64 })),
+        errorStateDetails: TlvOptionalField(2, TlvString.bound({ maxLength: 64 })),
+    });
+    RvcOperationalState.TlvOperationalCommandResponse = TlvObject({
+        commandResponseState: TlvField(0, RvcOperationalState.TlvErrorStateStruct),
+    });
+    RvcOperationalState.TlvOperationalErrorEvent = TlvObject({ errorState: TlvField(0, RvcOperationalState.TlvErrorStateStruct) });
+    RvcOperationalState.ClusterInstance = MutableCluster({
+        id: 0x61,
+        name: 'RvcOperationalState',
+        revision: 2,
+        attributes: {
+            phaseList: Attribute(0x0, TlvNullable(TlvArray(TlvString, { maxLength: 32 }))),
+            currentPhase: Attribute(0x1, TlvNullable(TlvUInt8)),
+            countdownTime: OptionalAttribute(0x2, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
+            operationalStateList: Attribute(0x3, TlvArray(RvcOperationalState.TlvOperationalStateStruct), { default: [] }),
+            operationalState: Attribute(0x4, TlvEnum()),
+            operationalError: Attribute(0x5, RvcOperationalState.TlvErrorStateStruct),
+        },
+        commands: {
+            pause: OptionalCommand(0x0, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            stop: OptionalCommand(0x1, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            start: OptionalCommand(0x2, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            resume: OptionalCommand(0x3, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+            goHome: OptionalCommand(0x80, TlvNoArguments, 0x4, RvcOperationalState.TlvOperationalCommandResponse),
+        },
+        events: {
+            operationalError: Event(0x0, EventPriority.Critical, RvcOperationalState.TlvOperationalErrorEvent),
+            operationCompletion: OptionalEvent(0x1, EventPriority.Info, OperationalStateNamespace.TlvOperationCompletionEvent),
+        },
+    });
+    RvcOperationalState.Cluster = RvcOperationalState.ClusterInstance;
+    RvcOperationalState.Complete = RvcOperationalState.Cluster;
+})(RvcOperationalState || (RvcOperationalState = {}));
+export const RvcOperationalStateCluster = RvcOperationalState.Cluster;
+ClusterRegistry.register(RvcOperationalState.Complete);