matterbridge-example-dynamic-platform 1.2.0-edge.7 → 1.2.0-edge.8

package/dist/appliances.js

@@ -1,10 +1,7 @@
-import { DeviceTypeId, Matterbridge, MatterbridgeEndpoint, MatterbridgeServer, MatterbridgeOnOffServer, Status, VendorId, smokeCoAlarm, RefrigeratorTag, PositionTag, laundryWasher, laundryDryer, dishwasher, refrigerator, temperatureControlledCabinetCooler, oven, temperatureControlledCabinetHeater, microwaveOven, extractorHood, cooktop, cookSurface, } from 'matterbridge';
-import { ClusterBehavior, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint } from 'matterbridge/matter';
-import { OperationalState, TemperatureControl, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, MicrowaveOvenMode, MicrowaveOvenControl, } from 'matterbridge/matter/clusters';
+import { MatterbridgeEndpoint, MatterbridgeServer, MatterbridgeOnOffServer, Status, RefrigeratorTag, PositionTag, laundryWasher, laundryDryer, dishwasher, refrigerator, temperatureControlledCabinetCooler, oven, temperatureControlledCabinetHeater, microwaveOven, extractorHood, cooktop, cookSurface, } from 'matterbridge';
+import { ClusterBehavior } from 'matterbridge/matter';
+import { OperationalState, TemperatureControl, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, OvenMode, RefrigeratorAndTemperatureControlledCabinetMode, MicrowaveOvenMode, MicrowaveOvenControl, OvenCavityOperationalState, } from 'matterbridge/matter/clusters';
 import { DishwasherAlarmServer, LaundryDryerControlsServer, LaundryWasherControlsServer, MicrowaveOvenControlBehavior, MicrowaveOvenModeServer, 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 {
     constructor(deviceType, name, serial) {
         super(deviceType, { uniqueStorageKey: `${name}-${serial}` }, true);
@@ -514,22 +511,3 @@ class LaundryWasherModeServer extends LaundryWasherModeBehavior {
         }
     }
 }
-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/robot.js

@@ -1,41 +1,40 @@
-import { MatterbridgeServer, MatterbridgeEndpoint, roboticVacuumCleaner } from 'matterbridge';
-import { RvcOperationalState } from './implementations/roboticVacuumCleanerClusters.js';
-import { ClusterBehavior } from 'matterbridge/matter';
+import { Matterbridge, MatterbridgeServer, MatterbridgeEndpoint, roboticVacuumCleaner } from 'matterbridge';
+import { LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint, DeviceTypeId, VendorId } from 'matterbridge/matter';
 import { Status } from 'matterbridge/matter/types';
-import { OperationalState, PowerSource, RvcRunMode, RvcCleanMode, ServiceArea } from 'matterbridge/matter/clusters';
-import { OnOffServer, ServiceAreaBehavior } from 'matterbridge/matter/behaviors';
+import { OperationalState, PowerSource, RvcRunMode, RvcCleanMode, RvcOperationalState, ServiceArea } from 'matterbridge/matter/clusters';
+import { RvcCleanModeBehavior, RvcOperationalStateBehavior, RvcRunModeBehavior, ServiceAreaBehavior } from 'matterbridge/matter/behaviors';
+import { AnsiLogger } from 'matterbridge/logger';
 export class Robot extends MatterbridgeEndpoint {
     constructor(name, serial) {
         super(roboticVacuumCleaner, { uniqueStorageKey: `${name}-${serial}` }, true);
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')
-            .createDefaultOnOffClusterServer()
             .createDefaultRvcRunModeClusterServer()
             .createDefaultRvcOperationalStateClusterServer()
             .createDefaultRvcCleanModeClusterServer()
             .createDefaultServiceAreaClusterServer()
             .createDefaultPowerSourceRechargeableBatteryClusterServer(80, PowerSource.BatChargeLevel.Ok, 5900);
     }
-    createDefaultRvcRunModeClusterServer() {
+    createDefaultRvcRunModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeRvcRunModeServer, {
-            supportedModes: [
+            supportedModes: supportedModes ?? [
                 { label: 'Idle', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
                 { label: 'Cleaning', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
                 { label: 'Mapping', mode: 3, modeTags: [{ value: RvcRunMode.ModeTag.Mapping }] },
                 { label: 'SpotCleaning', mode: 4, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }, { value: RvcRunMode.ModeTag.Max }] },
             ],
-            currentMode: 1,
+            currentMode: currentMode ?? 1,
         });
         return this;
     }
-    createDefaultRvcCleanModeClusterServer() {
+    createDefaultRvcCleanModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeRvcCleanModeServer, {
-            supportedModes: [
+            supportedModes: supportedModes ?? [
                 { label: 'Vacuum', mode: 1, modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }] },
                 { label: 'Mop', mode: 2, modeTags: [{ value: RvcCleanMode.ModeTag.Mop }] },
                 { label: 'Clean', mode: 3, modeTags: [{ value: RvcCleanMode.ModeTag.DeepClean }] },
             ],
-            currentMode: 1,
+            currentMode: currentMode ?? 1,
         });
         return this;
     }
@@ -104,36 +103,34 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaBehavior {
         return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
     }
 }
-export const RvcRunModeBehavior = ClusterBehavior.withInterface().for(RvcRunMode.Cluster);
 export class MatterbridgeRvcRunModeServer extends RvcRunModeBehavior {
     initialize() {
         this.state.currentMode = 1;
     }
     changeToMode({ newMode }) {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
-        if (!supported) {
+        const changedMode = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!changedMode) {
             device.log.error('MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode:', newMode);
             return { status: Status.InvalidCommand, statusText: 'Invalid command' };
         }
         device.changeToMode({ newMode });
         this.state.currentMode = newMode;
-        if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
+        if (changedMode.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
             device.log.info('***MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
             this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
             return { status: Status.Success, statusText: 'Running' };
         }
-        else if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
+        else if (changedMode.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
             device.log.info('***MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
             this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
             return { status: Status.Success, statusText: 'Docked' };
         }
-        device.log.info(`***MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        device.log.info(`***MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${changedMode.label}`);
         this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
         return { status: Status.Success, statusText: 'Success' };
     }
 }
-export const RvcCleanModeBehavior = ClusterBehavior.withInterface().for(RvcCleanMode.Cluster);
 export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior {
     initialize() {
         this.state.currentMode = 1;
@@ -151,29 +148,12 @@ export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior {
         return { status: Status.Success, statusText: 'Success' };
     }
 }
-export const RvcOperationalStateBehavior = ClusterBehavior.withInterface().for(RvcOperationalState.Cluster);
 export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBehavior {
     initialize() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.log.info('***MatterbridgeRvcOperationalStateServer initialized: setting operational state to Docked');
         this.state.operationalState = RvcOperationalState.OperationalState.Docked;
         this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
-        this.reactTo(this.agent.get(OnOffServer).events.onOff$Changed, this.handleOnOffChange);
-    }
-    handleOnOffChange(onOff) {
-        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
-        if (onOff) {
-            device.log.info('***OnOffServer changed to ON: setting operational state to Running');
-            this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
-            this.state.operationalState = RvcOperationalState.OperationalState.Running;
-            this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
-        }
-        else {
-            device.log.info('***OnOffServer changed to OFF: setting operational state to Docked');
-            this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
-            this.state.operationalState = RvcOperationalState.OperationalState.Docked;
-            this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
-        }
     }
     pause() {
         const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
@@ -206,3 +186,22 @@ export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBe
         };
     }
 }
+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 = roboticVacuumCleaner;
+    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/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.2.0-edge.7",
+  "version": "1.2.0-edge.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-example-dynamic-platform",
-      "version": "1.2.0-edge.7",
+      "version": "1.2.0-edge.8",
       "license": "MIT",
       "dependencies": {
         "node-ansi-logger": "3.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.2.0-edge.7",
+  "version": "1.2.0-edge.8",
   "description": "Matterbridge dynamic plugin",
   "author": "https://github.com/Luligu",
   "license": "MIT",

package/dist/implementations/carbonMonoxideConcentrationMeasurement.js

@@ -1,113 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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);