@matter/node 0.16.0-alpha.0-20251023-bb23617e5 → 0.16.0-alpha.0-20251029-bd92894d4

package/dist/esm/devices/on-off-light.js

@@ -5,10 +5,10 @@
  */
 import { IdentifyServer as BaseIdentifyServer } from "../behaviors/identify/IdentifyServer.js";
 import { GroupsServer as BaseGroupsServer } from "../behaviors/groups/GroupsServer.js";
-import { OnOffServer as BaseOnOffServer } from "../behaviors/on-off/OnOffServer.js";
 import {
   ScenesManagementServer as BaseScenesManagementServer
 } from "../behaviors/scenes-management/ScenesManagementServer.js";
+import { OnOffServer as BaseOnOffServer } from "../behaviors/on-off/OnOffServer.js";
 import { LevelControlServer as BaseLevelControlServer } from "../behaviors/level-control/LevelControlServer.js";
 import {
   OccupancySensingBehavior as BaseOccupancySensingBehavior
@@ -19,8 +19,8 @@ var OnOffLightRequirements;
 ((OnOffLightRequirements2) => {
   OnOffLightRequirements2.IdentifyServer = BaseIdentifyServer.alter({ commands: { triggerEffect: { optional: false } } });
   OnOffLightRequirements2.GroupsServer = BaseGroupsServer;
+  OnOffLightRequirements2.ScenesManagementServer = BaseScenesManagementServer.alter({ commands: { copyScene: { optional: false } } });
   OnOffLightRequirements2.OnOffServer = BaseOnOffServer.with("Lighting");
-  OnOffLightRequirements2.ScenesManagementServer = BaseScenesManagementServer;
   OnOffLightRequirements2.LevelControlServer = BaseLevelControlServer.with("OnOff", "Lighting").alter({
     attributes: {
       currentLevel: { min: 1, max: 254 },
@@ -30,8 +30,13 @@ var OnOffLightRequirements;
   });
   OnOffLightRequirements2.OccupancySensingBehavior = BaseOccupancySensingBehavior;
   OnOffLightRequirements2.server = {
-    mandatory: { Identify: OnOffLightRequirements2.IdentifyServer, Groups: OnOffLightRequirements2.GroupsServer, OnOff: OnOffLightRequirements2.OnOffServer },
-    optional: { ScenesManagement: OnOffLightRequirements2.ScenesManagementServer, LevelControl: OnOffLightRequirements2.LevelControlServer }
+    mandatory: {
+      Identify: OnOffLightRequirements2.IdentifyServer,
+      Groups: OnOffLightRequirements2.GroupsServer,
+      ScenesManagement: OnOffLightRequirements2.ScenesManagementServer,
+      OnOff: OnOffLightRequirements2.OnOffServer
+    },
+    optional: { LevelControl: OnOffLightRequirements2.LevelControlServer }
   };
   OnOffLightRequirements2.client = { optional: { OccupancySensing: OnOffLightRequirements2.OccupancySensingBehavior }, mandatory: {} };
 })(OnOffLightRequirements || (OnOffLightRequirements = {}));
@@ -43,6 +48,7 @@ const OnOffLightDeviceDefinition = MutableEndpoint({
   behaviors: SupportedBehaviors(
     OnOffLightRequirements.server.mandatory.Identify,
     OnOffLightRequirements.server.mandatory.Groups,
+    OnOffLightRequirements.server.mandatory.ScenesManagement,
     OnOffLightRequirements.server.mandatory.OnOff
   )
 });

package/dist/esm/devices/on-off-light.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/devices/on-off-light.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,kBAAkB,0BAA0B;AACrD,SAAS,gBAAgB,wBAAwB;AACjD,SAAS,eAAe,uBAAuB;AAC/C;AAAA,EACI,0BAA0B;AAAA,OACvB;AACP,SAAS,sBAAsB,8BAA8B;AAC7D;AAAA,EACI,4BAA4B;AAAA,OACzB;AACP,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAY5B,IAAU;AAAA,CAAV,CAAUA,4BAAV;AAMI,EAAMA,wBAAA,iBAAiB,mBAAmB,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAOpG,EAAMA,wBAAA,eAAe;AAOrB,EAAMA,wBAAA,cAAc,gBAAgB,KAAK,UAAU;AAOnD,EAAMA,wBAAA,yBAAyB;AAO/B,EAAMA,wBAAA,qBAAqB,uBAC7B,KAAK,SAAS,UAAU,EACxB,MAAM;AAAA,IACH,YAAY;AAAA,MACR,cAAc,EAAE,KAAK,GAAG,KAAK,IAAI;AAAA,MACjC,UAAU,EAAE,SAAS,GAAG,KAAK,GAAG,KAAK,EAAE;AAAA,MACvC,UAAU,EAAE,SAAS,KAAK,KAAK,KAAK,KAAK,IAAI;AAAA,IACjD;AAAA,EACJ,CAAC;AAOE,EAAMA,wBAAA,2BAA2B;AAKjC,EAAMA,wBAAA,SAAS;AAAA,IAClB,WAAW,EAAE,UAAUA,wBAAA,gBAAgB,QAAQA,wBAAA,cAAc,OAAOA,wBAAA,YAAY;AAAA,IAChF,UAAU,EAAE,kBAAkBA,wBAAA,wBAAwB,cAAcA,wBAAA,mBAAmB;AAAA,EAC3F;AAKO,EAAMA,wBAAA,SAAS,EAAE,UAAU,EAAE,kBAAkBA,wBAAA,yBAAyB,GAAG,WAAW,CAAC,EAAE;AAAA,GA9DnF;AAiEV,MAAM,6BAA6B,gBAAgB;AAAA,EACtD,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAAA,EACd,WAAW;AAAA,IACP,uBAAuB,OAAO,UAAU;AAAA,IACxC,uBAAuB,OAAO,UAAU;AAAA,IACxC,uBAAuB,OAAO,UAAU;AAAA,EAC5C;AACJ,CAAC;AAEM,MAAM,mBAAqC;",
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,kBAAkB,0BAA0B;AACrD,SAAS,gBAAgB,wBAAwB;AACjD;AAAA,EACI,0BAA0B;AAAA,OACvB;AACP,SAAS,eAAe,uBAAuB;AAC/C,SAAS,sBAAsB,8BAA8B;AAC7D;AAAA,EACI,4BAA4B;AAAA,OACzB;AACP,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAY5B,IAAU;AAAA,CAAV,CAAUA,4BAAV;AAMI,EAAMA,wBAAA,iBAAiB,mBAAmB,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAOpG,EAAMA,wBAAA,eAAe;AAOrB,EAAMA,wBAAA,yBAAyB,2BACjC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAOpD,EAAMA,wBAAA,cAAc,gBAAgB,KAAK,UAAU;AAOnD,EAAMA,wBAAA,qBAAqB,uBAC7B,KAAK,SAAS,UAAU,EACxB,MAAM;AAAA,IACH,YAAY;AAAA,MACR,cAAc,EAAE,KAAK,GAAG,KAAK,IAAI;AAAA,MACjC,UAAU,EAAE,SAAS,GAAG,KAAK,GAAG,KAAK,EAAE;AAAA,MACvC,UAAU,EAAE,SAAS,KAAK,KAAK,KAAK,KAAK,IAAI;AAAA,IACjD;AAAA,EACJ,CAAC;AAOE,EAAMA,wBAAA,2BAA2B;AAKjC,EAAMA,wBAAA,SAAS;AAAA,IAClB,WAAW;AAAA,MACP,UAAUA,wBAAA;AAAA,MACV,QAAQA,wBAAA;AAAA,MACR,kBAAkBA,wBAAA;AAAA,MAClB,OAAOA,wBAAA;AAAA,IACX;AAAA,IAEA,UAAU,EAAE,cAAcA,wBAAA,mBAAmB;AAAA,EACjD;AAKO,EAAMA,wBAAA,SAAS,EAAE,UAAU,EAAE,kBAAkBA,wBAAA,yBAAyB,GAAG,WAAW,CAAC,EAAE;AAAA,GArEnF;AAwEV,MAAM,6BAA6B,gBAAgB;AAAA,EACtD,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAAA,EAEd,WAAW;AAAA,IACP,uBAAuB,OAAO,UAAU;AAAA,IACxC,uBAAuB,OAAO,UAAU;AAAA,IACxC,uBAAuB,OAAO,UAAU;AAAA,IACxC,uBAAuB,OAAO,UAAU;AAAA,EAC5C;AACJ,CAAC;AAEM,MAAM,mBAAqC;",
   "names": ["OnOffLightRequirements"]
 }

package/dist/esm/devices/on-off-plug-in-unit.d.ts

@@ -6,8 +6,8 @@
 /*** THIS FILE IS GENERATED, DO NOT EDIT ***/
 import { IdentifyServer as BaseIdentifyServer } from "../behaviors/identify/IdentifyServer.js";
 import { GroupsServer as BaseGroupsServer } from "../behaviors/groups/GroupsServer.js";
-import { OnOffServer as BaseOnOffServer } from "../behaviors/on-off/OnOffServer.js";
 import { ScenesManagementServer as BaseScenesManagementServer } from "../behaviors/scenes-management/ScenesManagementServer.js";
+import { OnOffServer as BaseOnOffServer } from "../behaviors/on-off/OnOffServer.js";
 import { LevelControlServer as BaseLevelControlServer } from "../behaviors/level-control/LevelControlServer.js";
 import { MutableEndpoint } from "../endpoint/type/MutableEndpoint.js";
 import { Identity } from "#general";
@@ -15,6 +15,17 @@ import { Identity } from "#general";
  * An On/Off Plug-in Unit is a device that provides power to another device that is plugged into it, and is capable of
  * switching that provided power on or off.
  *
+ * The Mounted On/Off Control (added in Matter 1.4) has identical cluster requirements as the On/Off Plug-In Unit, and
+ * is marked as superset of this device type (since Matter 1.4.2). For devices intended to be mounted permanently, the
+ * Mounted On/Off Control device type shall be used, with the On/Off Plug-In Unit device type optionally added in the
+ * DeviceTypeList of the Descriptor cluster in addition to the On/Off Plug-In Unit device type (see
+ * [ref_MountedOnOffControlServerGuidance]).
+ *
+ * ### Before Matter 1.4, mounted units typically used the On/Off Plug-In Unit device type. Clients can encounter
+ * devices which were made before or after these specification updates. Therefore, clients SHOULD use the following
+ * heuristic to distinguish the type of physical device based on the device type revision found on an endpoint ("--"
+ * means the device type is not listed).
+ *
  * @see {@link MatterSpecification.v141.Device} § 5.1
  */
 export interface OnOffPlugInUnitDevice extends Identity<typeof OnOffPlugInUnitDeviceDefinition> {
@@ -25,7 +36,7 @@ export declare namespace OnOffPlugInUnitRequirements {
      *
      * This version of {@link IdentifyServer} is specialized per the specification.
      */
-    const IdentifyServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
+    const IdentifyServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
         readonly commands: {
             readonly triggerEffect: {
                 readonly optional: false;
@@ -39,23 +50,29 @@ export declare namespace OnOffPlugInUnitRequirements {
      */
     const GroupsServer: typeof BaseGroupsServer;
     /**
-     * The OnOff cluster is required by the Matter specification.
+     * The ScenesManagement cluster is required by the Matter specification.
      *
-     * This version of {@link OnOffServer} is specialized per the specification.
+     * This version of {@link ScenesManagementServer} is specialized per the specification.
      */
-    const OnOffServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/on-off").OnOff.Cluster, readonly [import("@matter/types/clusters/on-off").OnOff.Feature.Lighting]>, readonly []>, readonly ["Lighting"]>, typeof BaseOnOffServer, import("../behaviors/index.js").OnOffInterface>;
+    const ScenesManagementServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/scenes-management").ScenesManagement.Cluster, {
+        readonly commands: {
+            readonly copyScene: {
+                readonly optional: false;
+            };
+        };
+    }>, typeof BaseScenesManagementServer, import("../behaviors/index.js").ScenesManagementInterface>;
     /**
-     * The ScenesManagement cluster is optional per the Matter specification.
+     * The OnOff cluster is required by the Matter specification.
      *
-     * We provide this alias to the default implementation {@link ScenesManagementServer} for convenience.
+     * This version of {@link OnOffServer} is specialized per the specification.
      */
-    const ScenesManagementServer: typeof BaseScenesManagementServer;
+    const OnOffServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/on-off").OnOff.Cluster, readonly [import("@matter/types/clusters/on-off").OnOff.Feature.Lighting]>, readonly []>, readonly ["Lighting"]>, typeof BaseOnOffServer, import("../behaviors/index.js").OnOffInterface>;
     /**
      * The LevelControl cluster is optional per the Matter specification.
      *
      * This version of {@link LevelControlServer} is specialized per the specification.
      */
-    const LevelControlServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+    const LevelControlServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
         readonly id: 8;
         readonly name: "LevelControl";
         readonly revision: 6;
@@ -394,7 +411,7 @@ export declare namespace OnOffPlugInUnitRequirements {
      */
     const server: {
         mandatory: {
-            Identify: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
+            Identify: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
                 readonly commands: {
                     readonly triggerEffect: {
                         readonly optional: false;
@@ -402,11 +419,17 @@ export declare namespace OnOffPlugInUnitRequirements {
                 };
             }>, typeof BaseIdentifyServer, import("../behaviors/index.js").IdentifyInterface>;
             Groups: typeof BaseGroupsServer;
+            ScenesManagement: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/scenes-management").ScenesManagement.Cluster, {
+                readonly commands: {
+                    readonly copyScene: {
+                        readonly optional: false;
+                    };
+                };
+            }>, typeof BaseScenesManagementServer, import("../behaviors/index.js").ScenesManagementInterface>;
             OnOff: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/on-off").OnOff.Cluster, readonly [import("@matter/types/clusters/on-off").OnOff.Feature.Lighting]>, readonly []>, readonly ["Lighting"]>, typeof BaseOnOffServer, import("../behaviors/index.js").OnOffInterface>;
         };
         optional: {
-            ScenesManagement: typeof BaseScenesManagementServer;
-            LevelControl: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+            LevelControl: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
                 readonly id: 8;
                 readonly name: "LevelControl";
                 readonly revision: 6;
@@ -749,10 +772,10 @@ export declare namespace OnOffPlugInUnitRequirements {
 export declare const OnOffPlugInUnitDeviceDefinition: MutableEndpoint.With<import("../index.js").EndpointType.For<{
     readonly name: "OnOffPlugInUnit";
     readonly deviceType: 266;
-    readonly deviceRevision: 3;
+    readonly deviceRevision: 4;
     readonly requirements: typeof OnOffPlugInUnitRequirements;
     readonly behaviors: {
-        readonly identify: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
+        readonly identify: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
             readonly commands: {
                 readonly triggerEffect: {
                     readonly optional: false;
@@ -761,11 +784,19 @@ export declare const OnOffPlugInUnitDeviceDefinition: MutableEndpoint.With<impor
         }>, typeof BaseIdentifyServer, import("../behaviors/index.js").IdentifyInterface>;
     } & {
         readonly groups: typeof BaseGroupsServer;
+    } & {
+        readonly scenesManagement: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/scenes-management").ScenesManagement.Cluster, {
+            readonly commands: {
+                readonly copyScene: {
+                    readonly optional: false;
+                };
+            };
+        }>, typeof BaseScenesManagementServer, import("../behaviors/index.js").ScenesManagementInterface>;
     } & {
         readonly onOff: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/on-off").OnOff.Cluster, readonly [import("@matter/types/clusters/on-off").OnOff.Feature.Lighting]>, readonly []>, readonly ["Lighting"]>, typeof BaseOnOffServer, import("../behaviors/index.js").OnOffInterface>;
     };
 }>, {
-    readonly identify: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
+    readonly identify: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/identify").Identify.Cluster, {
         readonly commands: {
             readonly triggerEffect: {
                 readonly optional: false;
@@ -774,6 +805,14 @@ export declare const OnOffPlugInUnitDeviceDefinition: MutableEndpoint.With<impor
     }>, typeof BaseIdentifyServer, import("../behaviors/index.js").IdentifyInterface>;
 } & {
     readonly groups: typeof BaseGroupsServer;
+} & {
+    readonly scenesManagement: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/scenes-management").ScenesManagement.Cluster, {
+        readonly commands: {
+            readonly copyScene: {
+                readonly optional: false;
+            };
+        };
+    }>, typeof BaseScenesManagementServer, import("../behaviors/index.js").ScenesManagementInterface>;
 } & {
     readonly onOff: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types/clusters/on-off").OnOff.Cluster, readonly [import("@matter/types/clusters/on-off").OnOff.Feature.Lighting]>, readonly []>, readonly ["Lighting"]>, typeof BaseOnOffServer, import("../behaviors/index.js").OnOffInterface>;
 }>;

package/dist/esm/devices/on-off-plug-in-unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"on-off-plug-in-unit.d.ts","sourceRoot":"","sources":["../../../src/devices/on-off-plug-in-unit.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACpF,OAAO,EACH,sBAAsB,IAAI,0BAA0B,EACvD,MAAM,0DAA0D,CAAC;AAClE,OAAO,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAIhH,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,WAAW,qBAAsB,SAAQ,QAAQ,CAAC,OAAO,+BAA+B,CAAC;CAAG;AAElG,yBAAiB,2BAA2B,CAAC;IACzC;;;;OAIG;IACI,MAAM,cAAc;;;;;;qFAAiF,CAAC;IAE7G;;;;OAIG;IACI,MAAM,YAAY,yBAAmB,CAAC;IAE7C;;;;OAIG;IACI,MAAM,WAAW,4bAAmC,CAAC;IAE5D;;;;OAIG;IACI,MAAM,sBAAsB,mCAA6B,CAAC;IAEjE;;;;OAIG;IACI,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sLAQzB,CAAC;IAEP;;;;OAIG;IACI,MAAM,wBAAwB,0GAA+B,CAAC;IAErE;;OAEG;IACI,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGlB,CAAC;IAEF;;OAEG;IACI,MAAM,MAAM;;;;;KAA8E,CAAC;CACrG;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU1C,CAAC;AAEH,eAAO,MAAM,qBAAqB,EAAE,qBAAuD,CAAC"}
+{"version":3,"file":"on-off-plug-in-unit.d.ts","sourceRoot":"","sources":["../../../src/devices/on-off-plug-in-unit.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,EACH,sBAAsB,IAAI,0BAA0B,EACvD,MAAM,0DAA0D,CAAC;AAClE,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACpF,OAAO,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAIhH,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,qBAAsB,SAAQ,QAAQ,CAAC,OAAO,+BAA+B,CAAC;CAAG;AAElG,yBAAiB,2BAA2B,CAAC;IACzC;;;;OAIG;IACI,MAAM,cAAc;;;;;;qFAAiF,CAAC;IAE7G;;;;OAIG;IACI,MAAM,YAAY,yBAAmB,CAAC;IAE7C;;;;OAIG;IACI,MAAM,sBAAsB;;;;;;qGACyB,CAAC;IAE7D;;;;OAIG;IACI,MAAM,WAAW,4bAAmC,CAAC;IAE5D;;;;OAIG;IACI,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sLAQzB,CAAC;IAEP;;;;OAIG;IACI,MAAM,wBAAwB,0GAA+B,CAAC;IAErE;;OAEG;IACI,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KASlB,CAAC;IAEF;;OAEG;IACI,MAAM,MAAM;;;;;KAA8E,CAAC;CACrG;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY1C,CAAC;AAEH,eAAO,MAAM,qBAAqB,EAAE,qBAAuD,CAAC"}

package/dist/esm/devices/on-off-plug-in-unit.js

@@ -5,10 +5,10 @@
  */
 import { IdentifyServer as BaseIdentifyServer } from "../behaviors/identify/IdentifyServer.js";
 import { GroupsServer as BaseGroupsServer } from "../behaviors/groups/GroupsServer.js";
-import { OnOffServer as BaseOnOffServer } from "../behaviors/on-off/OnOffServer.js";
 import {
   ScenesManagementServer as BaseScenesManagementServer
 } from "../behaviors/scenes-management/ScenesManagementServer.js";
+import { OnOffServer as BaseOnOffServer } from "../behaviors/on-off/OnOffServer.js";
 import { LevelControlServer as BaseLevelControlServer } from "../behaviors/level-control/LevelControlServer.js";
 import {
   OccupancySensingBehavior as BaseOccupancySensingBehavior
@@ -19,8 +19,8 @@ var OnOffPlugInUnitRequirements;
 ((OnOffPlugInUnitRequirements2) => {
   OnOffPlugInUnitRequirements2.IdentifyServer = BaseIdentifyServer.alter({ commands: { triggerEffect: { optional: false } } });
   OnOffPlugInUnitRequirements2.GroupsServer = BaseGroupsServer;
+  OnOffPlugInUnitRequirements2.ScenesManagementServer = BaseScenesManagementServer.alter({ commands: { copyScene: { optional: false } } });
   OnOffPlugInUnitRequirements2.OnOffServer = BaseOnOffServer.with("Lighting");
-  OnOffPlugInUnitRequirements2.ScenesManagementServer = BaseScenesManagementServer;
   OnOffPlugInUnitRequirements2.LevelControlServer = BaseLevelControlServer.with("OnOff", "Lighting").alter({
     attributes: {
       currentLevel: { min: 1, max: 254 },
@@ -30,19 +30,25 @@ var OnOffPlugInUnitRequirements;
   });
   OnOffPlugInUnitRequirements2.OccupancySensingBehavior = BaseOccupancySensingBehavior;
   OnOffPlugInUnitRequirements2.server = {
-    mandatory: { Identify: OnOffPlugInUnitRequirements2.IdentifyServer, Groups: OnOffPlugInUnitRequirements2.GroupsServer, OnOff: OnOffPlugInUnitRequirements2.OnOffServer },
-    optional: { ScenesManagement: OnOffPlugInUnitRequirements2.ScenesManagementServer, LevelControl: OnOffPlugInUnitRequirements2.LevelControlServer }
+    mandatory: {
+      Identify: OnOffPlugInUnitRequirements2.IdentifyServer,
+      Groups: OnOffPlugInUnitRequirements2.GroupsServer,
+      ScenesManagement: OnOffPlugInUnitRequirements2.ScenesManagementServer,
+      OnOff: OnOffPlugInUnitRequirements2.OnOffServer
+    },
+    optional: { LevelControl: OnOffPlugInUnitRequirements2.LevelControlServer }
   };
   OnOffPlugInUnitRequirements2.client = { optional: { OccupancySensing: OnOffPlugInUnitRequirements2.OccupancySensingBehavior }, mandatory: {} };
 })(OnOffPlugInUnitRequirements || (OnOffPlugInUnitRequirements = {}));
 const OnOffPlugInUnitDeviceDefinition = MutableEndpoint({
   name: "OnOffPlugInUnit",
   deviceType: 266,
-  deviceRevision: 3,
+  deviceRevision: 4,
   requirements: OnOffPlugInUnitRequirements,
   behaviors: SupportedBehaviors(
     OnOffPlugInUnitRequirements.server.mandatory.Identify,
     OnOffPlugInUnitRequirements.server.mandatory.Groups,
+    OnOffPlugInUnitRequirements.server.mandatory.ScenesManagement,
     OnOffPlugInUnitRequirements.server.mandatory.OnOff
   )
 });

package/dist/esm/devices/on-off-plug-in-unit.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/devices/on-off-plug-in-unit.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,kBAAkB,0BAA0B;AACrD,SAAS,gBAAgB,wBAAwB;AACjD,SAAS,eAAe,uBAAuB;AAC/C;AAAA,EACI,0BAA0B;AAAA,OACvB;AACP,SAAS,sBAAsB,8BAA8B;AAC7D;AAAA,EACI,4BAA4B;AAAA,OACzB;AACP,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAW5B,IAAU;AAAA,CAAV,CAAUA,iCAAV;AAMI,EAAMA,6BAAA,iBAAiB,mBAAmB,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAOpG,EAAMA,6BAAA,eAAe;AAOrB,EAAMA,6BAAA,cAAc,gBAAgB,KAAK,UAAU;AAOnD,EAAMA,6BAAA,yBAAyB;AAO/B,EAAMA,6BAAA,qBAAqB,uBAC7B,KAAK,SAAS,UAAU,EACxB,MAAM;AAAA,IACH,YAAY;AAAA,MACR,cAAc,EAAE,KAAK,GAAG,KAAK,IAAI;AAAA,MACjC,UAAU,EAAE,SAAS,GAAG,KAAK,GAAG,KAAK,EAAE;AAAA,MACvC,UAAU,EAAE,SAAS,KAAK,KAAK,KAAK,KAAK,IAAI;AAAA,IACjD;AAAA,EACJ,CAAC;AAOE,EAAMA,6BAAA,2BAA2B;AAKjC,EAAMA,6BAAA,SAAS;AAAA,IAClB,WAAW,EAAE,UAAUA,6BAAA,gBAAgB,QAAQA,6BAAA,cAAc,OAAOA,6BAAA,YAAY;AAAA,IAChF,UAAU,EAAE,kBAAkBA,6BAAA,wBAAwB,cAAcA,6BAAA,mBAAmB;AAAA,EAC3F;AAKO,EAAMA,6BAAA,SAAS,EAAE,UAAU,EAAE,kBAAkBA,6BAAA,yBAAyB,GAAG,WAAW,CAAC,EAAE;AAAA,GA9DnF;AAiEV,MAAM,kCAAkC,gBAAgB;AAAA,EAC3D,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAAA,EACd,WAAW;AAAA,IACP,4BAA4B,OAAO,UAAU;AAAA,IAC7C,4BAA4B,OAAO,UAAU;AAAA,IAC7C,4BAA4B,OAAO,UAAU;AAAA,EACjD;AACJ,CAAC;AAEM,MAAM,wBAA+C;",
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,kBAAkB,0BAA0B;AACrD,SAAS,gBAAgB,wBAAwB;AACjD;AAAA,EACI,0BAA0B;AAAA,OACvB;AACP,SAAS,eAAe,uBAAuB;AAC/C,SAAS,sBAAsB,8BAA8B;AAC7D;AAAA,EACI,4BAA4B;AAAA,OACzB;AACP,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAsB5B,IAAU;AAAA,CAAV,CAAUA,iCAAV;AAMI,EAAMA,6BAAA,iBAAiB,mBAAmB,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAOpG,EAAMA,6BAAA,eAAe;AAOrB,EAAMA,6BAAA,yBAAyB,2BACjC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAOpD,EAAMA,6BAAA,cAAc,gBAAgB,KAAK,UAAU;AAOnD,EAAMA,6BAAA,qBAAqB,uBAC7B,KAAK,SAAS,UAAU,EACxB,MAAM;AAAA,IACH,YAAY;AAAA,MACR,cAAc,EAAE,KAAK,GAAG,KAAK,IAAI;AAAA,MACjC,UAAU,EAAE,SAAS,GAAG,KAAK,GAAG,KAAK,EAAE;AAAA,MACvC,UAAU,EAAE,SAAS,KAAK,KAAK,KAAK,KAAK,IAAI;AAAA,IACjD;AAAA,EACJ,CAAC;AAOE,EAAMA,6BAAA,2BAA2B;AAKjC,EAAMA,6BAAA,SAAS;AAAA,IAClB,WAAW;AAAA,MACP,UAAUA,6BAAA;AAAA,MACV,QAAQA,6BAAA;AAAA,MACR,kBAAkBA,6BAAA;AAAA,MAClB,OAAOA,6BAAA;AAAA,IACX;AAAA,IAEA,UAAU,EAAE,cAAcA,6BAAA,mBAAmB;AAAA,EACjD;AAKO,EAAMA,6BAAA,SAAS,EAAE,UAAU,EAAE,kBAAkBA,6BAAA,yBAAyB,GAAG,WAAW,CAAC,EAAE;AAAA,GArEnF;AAwEV,MAAM,kCAAkC,gBAAgB;AAAA,EAC3D,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAAA,EAEd,WAAW;AAAA,IACP,4BAA4B,OAAO,UAAU;AAAA,IAC7C,4BAA4B,OAAO,UAAU;AAAA,IAC7C,4BAA4B,OAAO,UAAU;AAAA,IAC7C,4BAA4B,OAAO,UAAU;AAAA,EACjD;AACJ,CAAC;AAEM,MAAM,wBAA+C;",
   "names": ["OnOffPlugInUnitRequirements"]
 }

package/dist/esm/devices/rain-sensor.d.ts

@@ -28,7 +28,7 @@ export declare namespace RainSensorRequirements {
      *
      * This version of {@link BooleanStateServer} is specialized per the specification.
      */
-    const BooleanStateServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
+    const BooleanStateServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
         readonly events: {
             readonly stateChange: {
                 readonly optional: false;
@@ -49,7 +49,7 @@ export declare namespace RainSensorRequirements {
     const server: {
         mandatory: {
             Identify: typeof BaseIdentifyServer;
-            BooleanState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
+            BooleanState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
                 readonly events: {
                     readonly stateChange: {
                         readonly optional: false;
@@ -72,7 +72,7 @@ export declare const RainSensorDeviceDefinition: MutableEndpoint.With<import("..
     readonly behaviors: {
         readonly identify: typeof BaseIdentifyServer;
     } & {
-        readonly booleanState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
+        readonly booleanState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
             readonly events: {
                 readonly stateChange: {
                     readonly optional: false;
@@ -85,7 +85,7 @@ export declare const RainSensorDeviceDefinition: MutableEndpoint.With<import("..
 }>, {
     readonly identify: typeof BaseIdentifyServer;
 } & {
-    readonly booleanState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ElementModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
+    readonly booleanState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/boolean-state").BooleanState.Cluster, {
         readonly events: {
             readonly stateChange: {
                 readonly optional: false;

package/dist/esm/devices/robotic-vacuum-cleaner.d.ts

@@ -34,9 +34,15 @@ export declare namespace RoboticVacuumCleanerRequirements {
     /**
      * The RvcOperationalState cluster is required by the Matter specification.
      *
-     * We provide this alias to the default implementation {@link RvcOperationalStateServer} for convenience.
+     * This version of {@link RvcOperationalStateServer} is specialized per the specification.
      */
-    const RvcOperationalStateServer: typeof BaseRvcOperationalStateServer;
+    const RvcOperationalStateServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/rvc-operational-state").RvcOperationalState.Cluster, {
+        readonly events: {
+            readonly operationCompletion: {
+                readonly optional: false;
+            };
+        };
+    }>, typeof BaseRvcOperationalStateServer, import("../behaviors/index.js").RvcOperationalStateInterface>;
     /**
      * The RvcCleanMode cluster is optional per the Matter specification.
      *
@@ -56,7 +62,13 @@ export declare namespace RoboticVacuumCleanerRequirements {
         mandatory: {
             Identify: typeof BaseIdentifyServer;
             RvcRunMode: typeof BaseRvcRunModeServer;
-            RvcOperationalState: typeof BaseRvcOperationalStateServer;
+            RvcOperationalState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/rvc-operational-state").RvcOperationalState.Cluster, {
+                readonly events: {
+                    readonly operationCompletion: {
+                        readonly optional: false;
+                    };
+                };
+            }>, typeof BaseRvcOperationalStateServer, import("../behaviors/index.js").RvcOperationalStateInterface>;
         };
         optional: {
             RvcCleanMode: typeof BaseRvcCleanModeServer;
@@ -67,21 +79,33 @@ export declare namespace RoboticVacuumCleanerRequirements {
 export declare const RoboticVacuumCleanerDeviceDefinition: MutableEndpoint.With<import("../index.js").EndpointType.For<{
     readonly name: "RoboticVacuumCleaner";
     readonly deviceType: 116;
-    readonly deviceRevision: 3;
+    readonly deviceRevision: 4;
     readonly requirements: typeof RoboticVacuumCleanerRequirements;
     readonly behaviors: {
         readonly identify: typeof BaseIdentifyServer;
     } & {
         readonly rvcRunMode: typeof BaseRvcRunModeServer;
     } & {
-        readonly rvcOperationalState: typeof BaseRvcOperationalStateServer;
+        readonly rvcOperationalState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/rvc-operational-state").RvcOperationalState.Cluster, {
+            readonly events: {
+                readonly operationCompletion: {
+                    readonly optional: false;
+                };
+            };
+        }>, typeof BaseRvcOperationalStateServer, import("../behaviors/index.js").RvcOperationalStateInterface>;
     };
 }>, {
     readonly identify: typeof BaseIdentifyServer;
 } & {
     readonly rvcRunMode: typeof BaseRvcRunModeServer;
 } & {
-    readonly rvcOperationalState: typeof BaseRvcOperationalStateServer;
+    readonly rvcOperationalState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/rvc-operational-state").RvcOperationalState.Cluster, {
+        readonly events: {
+            readonly operationCompletion: {
+                readonly optional: false;
+            };
+        };
+    }>, typeof BaseRvcOperationalStateServer, import("../behaviors/index.js").RvcOperationalStateInterface>;
 }>;
 export declare const RoboticVacuumCleanerDevice: RoboticVacuumCleanerDevice;
 //# sourceMappingURL=robotic-vacuum-cleaner.d.ts.map

package/dist/esm/devices/robotic-vacuum-cleaner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"robotic-vacuum-cleaner.d.ts","sourceRoot":"","sources":["../../../src/devices/robotic-vacuum-cleaner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AACzG,OAAO,EACH,yBAAyB,IAAI,6BAA6B,EAC7D,MAAM,iEAAiE,CAAC;AACzE,OAAO,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,iBAAiB,IAAI,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAC5G,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;GAIG;AACH,MAAM,WAAW,0BAA2B,SAAQ,QAAQ,CAAC,OAAO,oCAAoC,CAAC;CAAG;AAE5G,yBAAiB,gCAAgC,CAAC;IAC9C;;;;OAIG;IACI,MAAM,cAAc,2BAAqB,CAAC;IAEjD;;;;OAIG;IACI,MAAM,gBAAgB,6BAAuB,CAAC;IAErD;;;;OAIG;IACI,MAAM,yBAAyB,sCAAgC,CAAC;IAEvE;;;;OAIG;IACI,MAAM,kBAAkB,+BAAyB,CAAC;IAEzD;;;;OAIG;IACI,MAAM,iBAAiB,8BAAwB,CAAC;IAEvD;;OAEG;IACI,MAAM,MAAM;;;;;;;;;;KAOlB,CAAC;CACL;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;EAU/C,CAAC;AAEH,eAAO,MAAM,0BAA0B,EAAE,0BAAiE,CAAC"}
+{"version":3,"file":"robotic-vacuum-cleaner.d.ts","sourceRoot":"","sources":["../../../src/devices/robotic-vacuum-cleaner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6CAA6C;AAE7C,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AACzG,OAAO,EACH,yBAAyB,IAAI,6BAA6B,EAC7D,MAAM,iEAAiE,CAAC;AACzE,OAAO,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,iBAAiB,IAAI,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAC5G,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;GAIG;AACH,MAAM,WAAW,0BAA2B,SAAQ,QAAQ,CAAC,OAAO,oCAAoC,CAAC;CAAG;AAE5G,yBAAiB,gCAAgC,CAAC;IAC9C;;;;OAIG;IACI,MAAM,cAAc,2BAAqB,CAAC;IAEjD;;;;OAIG;IACI,MAAM,gBAAgB,6BAAuB,CAAC;IAErD;;;;OAIG;IACI,MAAM,yBAAyB;;;;;;2GAC8B,CAAC;IAErE;;;;OAIG;IACI,MAAM,kBAAkB,+BAAyB,CAAC;IAEzD;;;;OAIG;IACI,MAAM,iBAAiB,8BAAwB,CAAC;IAEvD;;OAEG;IACI,MAAM,MAAM;;;;;;;;;;;;;;;;KAOlB,CAAC;CACL;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU/C,CAAC;AAEH,eAAO,MAAM,0BAA0B,EAAE,0BAAiE,CAAC"}

package/dist/esm/devices/robotic-vacuum-cleaner.js

@@ -16,7 +16,7 @@ var RoboticVacuumCleanerRequirements;
 ((RoboticVacuumCleanerRequirements2) => {
   RoboticVacuumCleanerRequirements2.IdentifyServer = BaseIdentifyServer;
   RoboticVacuumCleanerRequirements2.RvcRunModeServer = BaseRvcRunModeServer;
-  RoboticVacuumCleanerRequirements2.RvcOperationalStateServer = BaseRvcOperationalStateServer;
+  RoboticVacuumCleanerRequirements2.RvcOperationalStateServer = BaseRvcOperationalStateServer.alter({ events: { operationCompletion: { optional: false } } });
   RoboticVacuumCleanerRequirements2.RvcCleanModeServer = BaseRvcCleanModeServer;
   RoboticVacuumCleanerRequirements2.ServiceAreaServer = BaseServiceAreaServer;
   RoboticVacuumCleanerRequirements2.server = {
@@ -31,7 +31,7 @@ var RoboticVacuumCleanerRequirements;
 const RoboticVacuumCleanerDeviceDefinition = MutableEndpoint({
   name: "RoboticVacuumCleaner",
   deviceType: 116,
-  deviceRevision: 3,
+  deviceRevision: 4,
   requirements: RoboticVacuumCleanerRequirements,
   behaviors: SupportedBehaviors(
     RoboticVacuumCleanerRequirements.server.mandatory.Identify,

package/dist/esm/devices/robotic-vacuum-cleaner.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/devices/robotic-vacuum-cleaner.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,kBAAkB,0BAA0B;AACrD,SAAS,oBAAoB,4BAA4B;AACzD;AAAA,EACI,6BAA6B;AAAA,OAC1B;AACP,SAAS,sBAAsB,8BAA8B;AAC7D,SAAS,qBAAqB,6BAA6B;AAC3D,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAU5B,IAAU;AAAA,CAAV,CAAUA,sCAAV;AAMI,EAAMA,kCAAA,iBAAiB;AAOvB,EAAMA,kCAAA,mBAAmB;AAOzB,EAAMA,kCAAA,4BAA4B;AAOlC,EAAMA,kCAAA,qBAAqB;AAO3B,EAAMA,kCAAA,oBAAoB;AAK1B,EAAMA,kCAAA,SAAS;AAAA,IAClB,WAAW;AAAA,MACP,UAAUA,kCAAA;AAAA,MACV,YAAYA,kCAAA;AAAA,MACZ,qBAAqBA,kCAAA;AAAA,IACzB;AAAA,IACA,UAAU,EAAE,cAAcA,kCAAA,oBAAoB,aAAaA,kCAAA,kBAAkB;AAAA,EACjF;AAAA,GA9Ca;AAiDV,MAAM,uCAAuC,gBAAgB;AAAA,EAChE,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAAA,EACd,WAAW;AAAA,IACP,iCAAiC,OAAO,UAAU;AAAA,IAClD,iCAAiC,OAAO,UAAU;AAAA,IAClD,iCAAiC,OAAO,UAAU;AAAA,EACtD;AACJ,CAAC;AAEM,MAAM,6BAAyD;",
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,kBAAkB,0BAA0B;AACrD,SAAS,oBAAoB,4BAA4B;AACzD;AAAA,EACI,6BAA6B;AAAA,OAC1B;AACP,SAAS,sBAAsB,8BAA8B;AAC7D,SAAS,qBAAqB,6BAA6B;AAC3D,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAU5B,IAAU;AAAA,CAAV,CAAUA,sCAAV;AAMI,EAAMA,kCAAA,iBAAiB;AAOvB,EAAMA,kCAAA,mBAAmB;AAOzB,EAAMA,kCAAA,4BAA4B,8BACpC,MAAM,EAAE,QAAQ,EAAE,qBAAqB,EAAE,UAAU,MAAM,EAAE,EAAE,CAAC;AAO5D,EAAMA,kCAAA,qBAAqB;AAO3B,EAAMA,kCAAA,oBAAoB;AAK1B,EAAMA,kCAAA,SAAS;AAAA,IAClB,WAAW;AAAA,MACP,UAAUA,kCAAA;AAAA,MACV,YAAYA,kCAAA;AAAA,MACZ,qBAAqBA,kCAAA;AAAA,IACzB;AAAA,IACA,UAAU,EAAE,cAAcA,kCAAA,oBAAoB,aAAaA,kCAAA,kBAAkB;AAAA,EACjF;AAAA,GA/Ca;AAkDV,MAAM,uCAAuC,gBAAgB;AAAA,EAChE,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,cAAc;AAAA,EACd,WAAW;AAAA,IACP,iCAAiC,OAAO,UAAU;AAAA,IAClD,iCAAiC,OAAO,UAAU;AAAA,IAClD,iCAAiC,OAAO,UAAU;AAAA,EACtD;AACJ,CAAC;AAEM,MAAM,6BAAyD;",
   "names": ["RoboticVacuumCleanerRequirements"]
 }

package/dist/esm/devices/temperature-controlled-cabinet.d.ts

@@ -29,9 +29,73 @@ export declare namespace TemperatureControlledCabinetRequirements {
     /**
      * The TemperatureControl cluster is required by the Matter specification.
      *
-     * We provide this alias to the default implementation {@link TemperatureControlServer} for convenience.
+     * This version of {@link TemperatureControlServer} is specialized per the specification.
      */
-    const TemperatureControlServer: typeof BaseTemperatureControlServer;
+    const TemperatureControlServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+        readonly id: 86;
+        readonly name: "TemperatureControl";
+        readonly revision: 1;
+        readonly features: {
+            readonly temperatureNumber: import("@matter/types").BitFlag;
+            readonly temperatureLevel: import("@matter/types").BitFlag;
+            readonly temperatureStep: import("@matter/types").BitFlag;
+        };
+        readonly commands: {
+            readonly setTemperature: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                targetTemperature: import("@matter/types").OptionalFieldType<number>;
+                targetTemperatureLevel: import("@matter/types").OptionalFieldType<number>;
+            }>, void, any>;
+        };
+        readonly extensions: readonly [{
+            readonly flags: {
+                readonly temperatureNumber: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly temperatureSetpoint: import("@matter/types").Attribute<number, any>;
+                    readonly minTemperature: import("@matter/types").FixedAttribute<number, any>;
+                    readonly maxTemperature: import("@matter/types").FixedAttribute<number, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly temperatureStep: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly step: import("@matter/types").FixedAttribute<number, any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly temperatureLevel: true;
+            };
+            readonly component: {
+                readonly attributes: {
+                    readonly selectedTemperatureLevel: import("@matter/types").Attribute<number, any>;
+                    readonly supportedTemperatureLevels: import("@matter/types").Attribute<string[], any>;
+                };
+            };
+        }, {
+            readonly flags: {
+                readonly temperatureStep: true;
+                readonly temperatureNumber: false;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly temperatureNumber: true;
+                readonly temperatureLevel: true;
+            };
+            readonly component: false;
+        }, {
+            readonly flags: {
+                readonly temperatureNumber: false;
+                readonly temperatureLevel: false;
+            };
+            readonly component: false;
+        }];
+    }>, readonly ["TemperatureNumber"]>, typeof BaseTemperatureControlServer, import("../behaviors/index.js").TemperatureControlInterface>;
     /**
      * The TemperatureMeasurement cluster is optional per the Matter specification.
      *
@@ -54,28 +118,104 @@ export declare namespace TemperatureControlledCabinetRequirements {
     /**
      * The OvenCavityOperationalState cluster is optional per the Matter specification.
      *
-     * We provide this alias to the default implementation {@link OvenCavityOperationalStateServer} for convenience.
+     * This version of {@link OvenCavityOperationalStateServer} is specialized per the specification.
      */
-    const OvenCavityOperationalStateServer: typeof BaseOvenCavityOperationalStateServer;
+    const OvenCavityOperationalStateServer: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/oven-cavity-operational-state").OvenCavityOperationalState.Cluster, {
+        readonly events: {
+            readonly operationCompletion: {
+                readonly optional: false;
+            };
+        };
+    }>, typeof BaseOvenCavityOperationalStateServer, import("../behaviors/index.js").OvenCavityOperationalStateInterface>;
     /**
      * An implementation for each server cluster supported by the endpoint per the Matter specification.
      */
     const server: {
         mandatory: {
-            TemperatureControl: typeof BaseTemperatureControlServer;
+            TemperatureControl: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+                readonly id: 86;
+                readonly name: "TemperatureControl";
+                readonly revision: 1;
+                readonly features: {
+                    readonly temperatureNumber: import("@matter/types").BitFlag;
+                    readonly temperatureLevel: import("@matter/types").BitFlag;
+                    readonly temperatureStep: import("@matter/types").BitFlag;
+                };
+                readonly commands: {
+                    readonly setTemperature: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                        targetTemperature: import("@matter/types").OptionalFieldType<number>;
+                        targetTemperatureLevel: import("@matter/types").OptionalFieldType<number>;
+                    }>, void, any>;
+                };
+                readonly extensions: readonly [{
+                    readonly flags: {
+                        readonly temperatureNumber: true;
+                    };
+                    readonly component: {
+                        readonly attributes: {
+                            readonly temperatureSetpoint: import("@matter/types").Attribute<number, any>;
+                            readonly minTemperature: import("@matter/types").FixedAttribute<number, any>;
+                            readonly maxTemperature: import("@matter/types").FixedAttribute<number, any>;
+                        };
+                    };
+                }, {
+                    readonly flags: {
+                        readonly temperatureStep: true;
+                    };
+                    readonly component: {
+                        readonly attributes: {
+                            readonly step: import("@matter/types").FixedAttribute<number, any>;
+                        };
+                    };
+                }, {
+                    readonly flags: {
+                        readonly temperatureLevel: true;
+                    };
+                    readonly component: {
+                        readonly attributes: {
+                            readonly selectedTemperatureLevel: import("@matter/types").Attribute<number, any>;
+                            readonly supportedTemperatureLevels: import("@matter/types").Attribute<string[], any>;
+                        };
+                    };
+                }, {
+                    readonly flags: {
+                        readonly temperatureStep: true;
+                        readonly temperatureNumber: false;
+                    };
+                    readonly component: false;
+                }, {
+                    readonly flags: {
+                        readonly temperatureNumber: true;
+                        readonly temperatureLevel: true;
+                    };
+                    readonly component: false;
+                }, {
+                    readonly flags: {
+                        readonly temperatureNumber: false;
+                        readonly temperatureLevel: false;
+                    };
+                    readonly component: false;
+                }];
+            }>, readonly ["TemperatureNumber"]>, typeof BaseTemperatureControlServer, import("../behaviors/index.js").TemperatureControlInterface>;
         };
         optional: {
             TemperatureMeasurement: typeof BaseTemperatureMeasurementServer;
             RefrigeratorAndTemperatureControlledCabinetMode: typeof BaseRefrigeratorAndTemperatureControlledCabinetModeServer;
             OvenMode: typeof BaseOvenModeServer;
-            OvenCavityOperationalState: typeof BaseOvenCavityOperationalStateServer;
+            OvenCavityOperationalState: import("../index.js").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types/clusters/oven-cavity-operational-state").OvenCavityOperationalState.Cluster, {
+                readonly events: {
+                    readonly operationCompletion: {
+                        readonly optional: false;
+                    };
+                };
+            }>, typeof BaseOvenCavityOperationalStateServer, import("../behaviors/index.js").OvenCavityOperationalStateInterface>;
         };
     };
 }
 export declare const TemperatureControlledCabinetDeviceDefinition: MutableEndpoint.With<import("../index.js").EndpointType.For<{
     readonly name: "TemperatureControlledCabinet";
     readonly deviceType: 113;
-    readonly deviceRevision: 3;
+    readonly deviceRevision: 5;
     readonly requirements: typeof TemperatureControlledCabinetRequirements;
     readonly behaviors: {};
 }>, {}>;