@project-chip/matter.js 0.9.3 → 0.9.4

package/dist/esm/tlv/TlvSchema.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/tlv/TlvSchema.ts"],
-  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { Schema } from \"../schema/Schema.js\";\nimport { ByteArray, Endian } from \"../util/ByteArray.js\";\nimport { DataReader } from \"../util/DataReader.js\";\nimport { DataWriter } from \"../util/DataWriter.js\";\nimport { TlvCodec, TlvTag, TlvToPrimitive, TlvTypeLength } from \"./TlvCodec.js\";\n\nexport abstract class TlvSchema<T> extends Schema<T, ByteArray> implements TlvSchema<T> {\n    override decodeInternal(encoded: ByteArray): T {\n        return this.decodeTlvInternal(new TlvByteArrayReader(encoded)).value;\n    }\n\n    override encodeInternal(value: T): ByteArray {\n        const writer = new TlvByteArrayWriter();\n        this.encodeTlvInternal(writer, value);\n        return writer.toByteArray();\n    }\n\n    encodeTlv(value: T, forWriteInteraction = false): TlvStream {\n        const writer = new TlvArrayWriter();\n        this.encodeTlvInternal(writer, value, undefined, forWriteInteraction);\n        return writer.toTlvArray();\n    }\n\n    decodeTlv(encoded: TlvStream): T {\n        return this.decodeTlvInternal(new TlvArrayReader(encoded)).value;\n    }\n\n    decodeTlvInternal(reader: TlvReader): { value: T; tag?: TlvTag } {\n        const { tag, typeLength } = reader.readTagType();\n        return { tag, value: this.decodeTlvInternalValue(reader, typeLength) };\n    }\n\n    abstract decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): T;\n\n    abstract encodeTlvInternal(writer: TlvWriter, value: T, tag?: TlvTag, forWriteInteraction?: boolean): void;\n\n    injectField(value: T, _fieldId: number, _fieldValue: any, _injectChecker: (fieldValue: any) => boolean): T {\n        return value;\n    }\n\n    removeField(value: T, _fieldId: number, _removeChecker: (fieldValue: any) => boolean): T {\n        return value;\n    }\n}\n\nexport type TlvStream = TlvElement<any>[];\n\nexport type TlvElement<T extends TlvTypeLength> = {\n    tag?: TlvTag;\n    typeLength: T;\n    value?: TlvToPrimitive[T[\"type\"]];\n};\n\nexport class TlvArrayWriter implements TlvWriter {\n    private readonly tlvArray = new Array<TlvElement<any>>();\n\n    writeTag(typeLength: TlvTypeLength, tag?: TlvTag) {\n        this.tlvArray.push({ tag, typeLength });\n    }\n\n    writePrimitive<T extends TlvTypeLength>(_typeLength: T, value: TlvToPrimitive[T[\"type\"]]) {\n        this.tlvArray[this.tlvArray.length - 1].value = value;\n    }\n\n    toTlvArray() {\n        return this.tlvArray;\n    }\n}\n\nexport class TlvArrayReader implements TlvReader {\n    private index = -1;\n\n    constructor(private readonly tlvElements: TlvElement<any>[]) {}\n\n    readTagType() {\n        this.index++;\n        return this.tlvElements[this.index];\n    }\n\n    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T[\"type\"]]>(_typeLength: T): V {\n        return this.tlvElements[this.index].value;\n    }\n}\n\n/** Type defined by the TLV schema. */\nexport type TypeFromSchema<S extends TlvSchema<any>> = S extends TlvSchema<infer T> ? T : never;\n\nexport interface TlvReader {\n    readTagType(): { tag?: TlvTag; typeLength: TlvTypeLength };\n\n    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T[\"type\"]]>(typeLength: T): V;\n}\n\nexport interface TlvWriter {\n    writeTag(typeLength: TlvTypeLength, tag?: TlvTag): void;\n\n    writePrimitive<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T[\"type\"]]): void;\n}\n\nexport class TlvByteArrayWriter implements TlvWriter {\n    private readonly writer = new DataWriter(Endian.Little);\n\n    writeTag(typeLength: TlvTypeLength, tag?: TlvTag) {\n        TlvCodec.writeTag(this.writer, typeLength, tag);\n    }\n\n    writePrimitive<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T[\"type\"]]) {\n        TlvCodec.writePrimitive(this.writer, typeLength, value);\n    }\n\n    toByteArray() {\n        return this.writer.toByteArray();\n    }\n}\n\nexport class TlvByteArrayReader implements TlvReader {\n    private readonly reader: DataReader<Endian.Little>;\n\n    constructor(byteArray: ByteArray) {\n        this.reader = new DataReader(byteArray, Endian.Little);\n    }\n\n    readTagType() {\n        return TlvCodec.readTagType(this.reader);\n    }\n\n    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T[\"type\"]]>(typeLength: T): V {\n        return TlvCodec.readPrimitive(this.reader, typeLength);\n    }\n}\n"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,cAAc;AACvB,SAAoB,cAAc;AAClC,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB;AAC3B,SAAS,gBAAuD;AAEzD,MAAe,kBAAqB,OAA6C;AAAA,EAC3E,eAAe,SAAuB;AAC3C,WAAO,KAAK,kBAAkB,IAAI,mBAAmB,OAAO,CAAC,EAAE;AAAA,EACnE;AAAA,EAES,eAAe,OAAqB;AACzC,UAAM,SAAS,IAAI,mBAAmB;AACtC,SAAK,kBAAkB,QAAQ,KAAK;AACpC,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,UAAU,OAAU,sBAAsB,OAAkB;AACxD,UAAM,SAAS,IAAI,eAAe;AAClC,SAAK,kBAAkB,QAAQ,OAAO,QAAW,mBAAmB;AACpE,WAAO,OAAO,WAAW;AAAA,EAC7B;AAAA,EAEA,UAAU,SAAuB;AAC7B,WAAO,KAAK,kBAAkB,IAAI,eAAe,OAAO,CAAC,EAAE;AAAA,EAC/D;AAAA,EAEA,kBAAkB,QAA+C;AAC7D,UAAM,EAAE,KAAK,WAAW,IAAI,OAAO,YAAY;AAC/C,WAAO,EAAE,KAAK,OAAO,KAAK,uBAAuB,QAAQ,UAAU,EAAE;AAAA,EACzE;AAAA,EAMA,YAAY,OAAU,UAAkB,aAAkB,gBAAiD;AACvG,WAAO;AAAA,EACX;AAAA,EAEA,YAAY,OAAU,UAAkB,gBAAiD;AACrF,WAAO;AAAA,EACX;AACJ;AAUO,MAAM,eAAoC;AAAA,EAA1C;AACH,SAAiB,WAAW,IAAI,MAAuB;AAAA;AAAA,EAEvD,SAAS,YAA2B,KAAc;AAC9C,SAAK,SAAS,KAAK,EAAE,KAAK,WAAW,CAAC;AAAA,EAC1C;AAAA,EAEA,eAAwC,aAAgB,OAAkC;AACtF,SAAK,SAAS,KAAK,SAAS,SAAS,CAAC,EAAE,QAAQ;AAAA,EACpD;AAAA,EAEA,aAAa;AACT,WAAO,KAAK;AAAA,EAChB;AACJ;AAEO,MAAM,eAAoC;AAAA,EAG7C,YAA6B,aAAgC;AAAhC;AAF7B,SAAQ,QAAQ;AAAA,EAE8C;AAAA,EAE9D,cAAc;AACV,SAAK;AACL,WAAO,KAAK,YAAY,KAAK,KAAK;AAAA,EACtC;AAAA,EAEA,cAAsE,aAAmB;AACrF,WAAO,KAAK,YAAY,KAAK,KAAK,EAAE;AAAA,EACxC;AACJ;AAiBO,MAAM,mBAAwC;AAAA,EAA9C;AACH,SAAiB,SAAS,IAAI,WAAW,OAAO,MAAM;AAAA;AAAA,EAEtD,SAAS,YAA2B,KAAc;AAC9C,aAAS,SAAS,KAAK,QAAQ,YAAY,GAAG;AAAA,EAClD;AAAA,EAEA,eAAwC,YAAe,OAAkC;AACrF,aAAS,eAAe,KAAK,QAAQ,YAAY,KAAK;AAAA,EAC1D;AAAA,EAEA,cAAc;AACV,WAAO,KAAK,OAAO,YAAY;AAAA,EACnC;AACJ;AAEO,MAAM,mBAAwC;AAAA,EAGjD,YAAY,WAAsB;AAC9B,SAAK,SAAS,IAAI,WAAW,WAAW,OAAO,MAAM;AAAA,EACzD;AAAA,EAEA,cAAc;AACV,WAAO,SAAS,YAAY,KAAK,MAAM;AAAA,EAC3C;AAAA,EAEA,cAAsE,YAAkB;AACpF,WAAO,SAAS,cAAc,KAAK,QAAQ,UAAU;AAAA,EACzD;AACJ;",
+  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { Schema } from \"../schema/Schema.js\";\nimport { ByteArray, Endian } from \"../util/ByteArray.js\";\nimport { DataReader } from \"../util/DataReader.js\";\nimport { DataWriter } from \"../util/DataWriter.js\";\nimport { TlvCodec, TlvTag, TlvToPrimitive, TlvTypeLength } from \"./TlvCodec.js\";\n\nexport type TlvEncodingOptions = {\n    /**\n     * When true, the fabricIndex field will be excluded from the TLV encoding for list entries.\n     * This flag must not be set together with the following flag.\n     */\n    forWriteInteraction?: boolean;\n\n    /**\n     * When true, mandatory field validation is skipped when encoding TLV for list entries.\n     * This flag must not be set together with the former flag.\n     */\n    allowMissingFieldsForNonFabricFilteredRead?: boolean;\n};\n\nexport abstract class TlvSchema<T> extends Schema<T, ByteArray> implements TlvSchema<T> {\n    override decodeInternal(encoded: ByteArray): T {\n        return this.decodeTlvInternal(new TlvByteArrayReader(encoded)).value;\n    }\n\n    override encodeInternal(value: T): ByteArray {\n        const writer = new TlvByteArrayWriter();\n        this.encodeTlvInternal(writer, value);\n        return writer.toByteArray();\n    }\n\n    encodeTlv(value: T, options?: TlvEncodingOptions): TlvStream {\n        const writer = new TlvArrayWriter();\n        this.encodeTlvInternal(writer, value, undefined, options);\n        return writer.toTlvArray();\n    }\n\n    decodeTlv(encoded: TlvStream): T {\n        return this.decodeTlvInternal(new TlvArrayReader(encoded)).value;\n    }\n\n    decodeTlvInternal(reader: TlvReader): { value: T; tag?: TlvTag } {\n        const { tag, typeLength } = reader.readTagType();\n        return { tag, value: this.decodeTlvInternalValue(reader, typeLength) };\n    }\n\n    abstract decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): T;\n\n    abstract encodeTlvInternal(writer: TlvWriter, value: T, tag?: TlvTag, options?: TlvEncodingOptions): void;\n\n    injectField(value: T, _fieldId: number, _fieldValue: any, _injectChecker: (fieldValue: any) => boolean): T {\n        return value;\n    }\n\n    removeField(value: T, _fieldId: number, _removeChecker: (fieldValue: any) => boolean): T {\n        return value;\n    }\n}\n\nexport type TlvStream = TlvElement<any>[];\n\nexport type TlvElement<T extends TlvTypeLength> = {\n    tag?: TlvTag;\n    typeLength: T;\n    value?: TlvToPrimitive[T[\"type\"]];\n};\n\nexport class TlvArrayWriter implements TlvWriter {\n    private readonly tlvArray = new Array<TlvElement<any>>();\n\n    writeTag(typeLength: TlvTypeLength, tag?: TlvTag) {\n        this.tlvArray.push({ tag, typeLength });\n    }\n\n    writePrimitive<T extends TlvTypeLength>(_typeLength: T, value: TlvToPrimitive[T[\"type\"]]) {\n        this.tlvArray[this.tlvArray.length - 1].value = value;\n    }\n\n    toTlvArray() {\n        return this.tlvArray;\n    }\n}\n\nexport class TlvArrayReader implements TlvReader {\n    private index = -1;\n\n    constructor(private readonly tlvElements: TlvElement<any>[]) {}\n\n    readTagType() {\n        this.index++;\n        return this.tlvElements[this.index];\n    }\n\n    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T[\"type\"]]>(_typeLength: T): V {\n        return this.tlvElements[this.index].value;\n    }\n}\n\n/** Type defined by the TLV schema. */\nexport type TypeFromSchema<S extends TlvSchema<any>> = S extends TlvSchema<infer T> ? T : never;\n\nexport interface TlvReader {\n    readTagType(): { tag?: TlvTag; typeLength: TlvTypeLength };\n\n    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T[\"type\"]]>(typeLength: T): V;\n}\n\nexport interface TlvWriter {\n    writeTag(typeLength: TlvTypeLength, tag?: TlvTag): void;\n\n    writePrimitive<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T[\"type\"]]): void;\n}\n\nexport class TlvByteArrayWriter implements TlvWriter {\n    private readonly writer = new DataWriter(Endian.Little);\n\n    writeTag(typeLength: TlvTypeLength, tag?: TlvTag) {\n        TlvCodec.writeTag(this.writer, typeLength, tag);\n    }\n\n    writePrimitive<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T[\"type\"]]) {\n        TlvCodec.writePrimitive(this.writer, typeLength, value);\n    }\n\n    toByteArray() {\n        return this.writer.toByteArray();\n    }\n}\n\nexport class TlvByteArrayReader implements TlvReader {\n    private readonly reader: DataReader<Endian.Little>;\n\n    constructor(byteArray: ByteArray) {\n        this.reader = new DataReader(byteArray, Endian.Little);\n    }\n\n    readTagType() {\n        return TlvCodec.readTagType(this.reader);\n    }\n\n    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T[\"type\"]]>(typeLength: T): V {\n        return TlvCodec.readPrimitive(this.reader, typeLength);\n    }\n}\n"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,cAAc;AACvB,SAAoB,cAAc;AAClC,SAAS,kBAAkB;AAC3B,SAAS,kBAAkB;AAC3B,SAAS,gBAAuD;AAgBzD,MAAe,kBAAqB,OAA6C;AAAA,EAC3E,eAAe,SAAuB;AAC3C,WAAO,KAAK,kBAAkB,IAAI,mBAAmB,OAAO,CAAC,EAAE;AAAA,EACnE;AAAA,EAES,eAAe,OAAqB;AACzC,UAAM,SAAS,IAAI,mBAAmB;AACtC,SAAK,kBAAkB,QAAQ,KAAK;AACpC,WAAO,OAAO,YAAY;AAAA,EAC9B;AAAA,EAEA,UAAU,OAAU,SAAyC;AACzD,UAAM,SAAS,IAAI,eAAe;AAClC,SAAK,kBAAkB,QAAQ,OAAO,QAAW,OAAO;AACxD,WAAO,OAAO,WAAW;AAAA,EAC7B;AAAA,EAEA,UAAU,SAAuB;AAC7B,WAAO,KAAK,kBAAkB,IAAI,eAAe,OAAO,CAAC,EAAE;AAAA,EAC/D;AAAA,EAEA,kBAAkB,QAA+C;AAC7D,UAAM,EAAE,KAAK,WAAW,IAAI,OAAO,YAAY;AAC/C,WAAO,EAAE,KAAK,OAAO,KAAK,uBAAuB,QAAQ,UAAU,EAAE;AAAA,EACzE;AAAA,EAMA,YAAY,OAAU,UAAkB,aAAkB,gBAAiD;AACvG,WAAO;AAAA,EACX;AAAA,EAEA,YAAY,OAAU,UAAkB,gBAAiD;AACrF,WAAO;AAAA,EACX;AACJ;AAUO,MAAM,eAAoC;AAAA,EAA1C;AACH,SAAiB,WAAW,IAAI,MAAuB;AAAA;AAAA,EAEvD,SAAS,YAA2B,KAAc;AAC9C,SAAK,SAAS,KAAK,EAAE,KAAK,WAAW,CAAC;AAAA,EAC1C;AAAA,EAEA,eAAwC,aAAgB,OAAkC;AACtF,SAAK,SAAS,KAAK,SAAS,SAAS,CAAC,EAAE,QAAQ;AAAA,EACpD;AAAA,EAEA,aAAa;AACT,WAAO,KAAK;AAAA,EAChB;AACJ;AAEO,MAAM,eAAoC;AAAA,EAG7C,YAA6B,aAAgC;AAAhC;AAF7B,SAAQ,QAAQ;AAAA,EAE8C;AAAA,EAE9D,cAAc;AACV,SAAK;AACL,WAAO,KAAK,YAAY,KAAK,KAAK;AAAA,EACtC;AAAA,EAEA,cAAsE,aAAmB;AACrF,WAAO,KAAK,YAAY,KAAK,KAAK,EAAE;AAAA,EACxC;AACJ;AAiBO,MAAM,mBAAwC;AAAA,EAA9C;AACH,SAAiB,SAAS,IAAI,WAAW,OAAO,MAAM;AAAA;AAAA,EAEtD,SAAS,YAA2B,KAAc;AAC9C,aAAS,SAAS,KAAK,QAAQ,YAAY,GAAG;AAAA,EAClD;AAAA,EAEA,eAAwC,YAAe,OAAkC;AACrF,aAAS,eAAe,KAAK,QAAQ,YAAY,KAAK;AAAA,EAC1D;AAAA,EAEA,cAAc;AACV,WAAO,KAAK,OAAO,YAAY;AAAA,EACnC;AACJ;AAEO,MAAM,mBAAwC;AAAA,EAGjD,YAAY,WAAsB;AAC9B,SAAK,SAAS,IAAI,WAAW,WAAW,OAAO,MAAM;AAAA,EACzD;AAAA,EAEA,cAAc;AACV,WAAO,SAAS,YAAY,KAAK,MAAM;AAAA,EAC3C;AAAA,EAEA,cAAsE,YAAkB;AACpF,WAAO,SAAS,cAAc,KAAK,QAAQ,UAAU;AAAA,EACzD;AACJ;",
   "names": []
 }

package/dist/esm/tlv/TlvWrapper.d.ts

@@ -4,14 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { TlvTag, TlvTypeLength } from "./TlvCodec.js";
-import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+import { TlvEncodingOptions, TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
 export declare class TlvWrapper<O, T> extends TlvSchema<O> {
     protected readonly underlyingSchema: TlvSchema<T>;
     protected readonly wrap: (object: O) => T;
     private readonly unwrap;
     constructor(underlyingSchema: TlvSchema<T>, wrap: (object: O) => T, unwrap: (value: T) => O);
     decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): O;
-    encodeTlvInternal(writer: TlvWriter, value: O, tag?: TlvTag, forWriteInteraction?: boolean): void;
+    encodeTlvInternal(writer: TlvWriter, value: O, tag?: TlvTag, options?: TlvEncodingOptions): void;
     validate(value: O): void;
 }
 //# sourceMappingURL=TlvWrapper.d.ts.map

package/dist/esm/tlv/TlvWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TlvWrapper.d.ts","sourceRoot":"","sources":["../../../src/tlv/TlvWrapper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEjE,qBAAa,UAAU,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IAE1C,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC;IACjD,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFJ,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC,EAC9B,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EACxB,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC;IAKnC,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,GAAG,CAAC;IAIvE,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,OAAO,GAAG,IAAI;IAIjG,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;CAGpC"}
+{"version":3,"file":"TlvWrapper.d.ts","sourceRoot":"","sources":["../../../src/tlv/TlvWrapper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAErF,qBAAa,UAAU,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IAE1C,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC;IACjD,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFJ,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC,EAC9B,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,EACxB,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC;IAKnC,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,GAAG,CAAC;IAIvE,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAIhG,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;CAGpC"}

package/dist/esm/tlv/TlvWrapper.js

@@ -14,8 +14,8 @@ class TlvWrapper extends TlvSchema {
   decodeTlvInternalValue(reader, typeLength) {
     return this.unwrap(this.underlyingSchema.decodeTlvInternalValue(reader, typeLength));
   }
-  encodeTlvInternal(writer, value, tag, forWriteInteraction) {
-    this.underlyingSchema.encodeTlvInternal(writer, this.wrap(value), tag, forWriteInteraction);
+  encodeTlvInternal(writer, value, tag, options) {
+    this.underlyingSchema.encodeTlvInternal(writer, this.wrap(value), tag, options);
   }
   validate(value) {
     this.underlyingSchema.validate(this.wrap(value));

package/dist/esm/tlv/TlvWrapper.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/tlv/TlvWrapper.ts"],
-  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { TlvTag, TlvTypeLength } from \"./TlvCodec.js\";\nimport { TlvReader, TlvSchema, TlvWriter } from \"./TlvSchema.js\";\n\nexport class TlvWrapper<O, T> extends TlvSchema<O> {\n    constructor(\n        protected readonly underlyingSchema: TlvSchema<T>,\n        protected readonly wrap: (object: O) => T,\n        private readonly unwrap: (value: T) => O,\n    ) {\n        super();\n    }\n\n    override decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): O {\n        return this.unwrap(this.underlyingSchema.decodeTlvInternalValue(reader, typeLength));\n    }\n\n    override encodeTlvInternal(writer: TlvWriter, value: O, tag?: TlvTag, forWriteInteraction?: boolean): void {\n        this.underlyingSchema.encodeTlvInternal(writer, this.wrap(value), tag, forWriteInteraction);\n    }\n\n    override validate(value: O): void {\n        this.underlyingSchema.validate(this.wrap(value));\n    }\n}\n"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,SAAoB,iBAA4B;AAEzC,MAAM,mBAAyB,UAAa;AAAA,EAC/C,YACuB,kBACA,MACF,QACnB;AACE,UAAM;AAJa;AACA;AACF;AAAA,EAGrB;AAAA,EAES,uBAAuB,QAAmB,YAA8B;AAC7E,WAAO,KAAK,OAAO,KAAK,iBAAiB,uBAAuB,QAAQ,UAAU,CAAC;AAAA,EACvF;AAAA,EAES,kBAAkB,QAAmB,OAAU,KAAc,qBAAqC;AACvG,SAAK,iBAAiB,kBAAkB,QAAQ,KAAK,KAAK,KAAK,GAAG,KAAK,mBAAmB;AAAA,EAC9F;AAAA,EAES,SAAS,OAAgB;AAC9B,SAAK,iBAAiB,SAAS,KAAK,KAAK,KAAK,CAAC;AAAA,EACnD;AACJ;",
+  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { TlvTag, TlvTypeLength } from \"./TlvCodec.js\";\nimport { TlvEncodingOptions, TlvReader, TlvSchema, TlvWriter } from \"./TlvSchema.js\";\n\nexport class TlvWrapper<O, T> extends TlvSchema<O> {\n    constructor(\n        protected readonly underlyingSchema: TlvSchema<T>,\n        protected readonly wrap: (object: O) => T,\n        private readonly unwrap: (value: T) => O,\n    ) {\n        super();\n    }\n\n    override decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): O {\n        return this.unwrap(this.underlyingSchema.decodeTlvInternalValue(reader, typeLength));\n    }\n\n    override encodeTlvInternal(writer: TlvWriter, value: O, tag?: TlvTag, options?: TlvEncodingOptions): void {\n        this.underlyingSchema.encodeTlvInternal(writer, this.wrap(value), tag, options);\n    }\n\n    override validate(value: O): void {\n        this.underlyingSchema.validate(this.wrap(value));\n    }\n}\n"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,SAAwC,iBAA4B;AAE7D,MAAM,mBAAyB,UAAa;AAAA,EAC/C,YACuB,kBACA,MACF,QACnB;AACE,UAAM;AAJa;AACA;AACF;AAAA,EAGrB;AAAA,EAES,uBAAuB,QAAmB,YAA8B;AAC7E,WAAO,KAAK,OAAO,KAAK,iBAAiB,uBAAuB,QAAQ,UAAU,CAAC;AAAA,EACvF;AAAA,EAES,kBAAkB,QAAmB,OAAU,KAAc,SAAoC;AACtG,SAAK,iBAAiB,kBAAkB,QAAQ,KAAK,KAAK,KAAK,GAAG,KAAK,OAAO;AAAA,EAClF;AAAA,EAES,SAAS,OAAgB;AAC9B,SAAK,iBAAiB,SAAS,KAAK,KAAK,KAAK,CAAC;AAAA,EACnD;AACJ;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@project-chip/matter.js",
-    "version": "0.9.3",
+    "version": "0.9.4",
     "description": "Matter protocol in pure js",
     "keywords": [
         "iot",
@@ -36,7 +36,7 @@
         "@noble/curves": "^1.4.0"
     },
     "devDependencies": {
-        "@project-chip/matter.js-tools": "0.9.3",
+        "@project-chip/matter.js-tools": "0.9.4",
         "@types/chai": "^4.3.12",
         "@types/mocha": "^10.0.6",
         "@types/wtfnode": "^0.7.3",
@@ -169,5 +169,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "7bbb377e3a1a5ac4bb006b0573c25c2fe0d6dd75"
+    "gitHead": "eb59507fb8188184dd65c593b093e8d21b813ce7"
 }

package/src/CommissioningServer.ts

@@ -549,7 +549,6 @@ export class CommissioningServer extends MatterNode {
 
         this.interactionServer = new LegacyInteractionServer({
             endpointStructure: this.endpointStructure,
-            eventHandler: this.eventHandler,
             subscriptionOptions: {
                 maxIntervalSeconds: this.options.subscriptionMaxIntervalSeconds,
                 minIntervalSeconds: this.options.subscriptionMinIntervalSeconds,

package/src/MatterDevice.ts

@@ -56,6 +56,7 @@ export class MatterDevice {
     private readonly channelManager: ChannelManager;
     private readonly secureChannelProtocol = new SecureChannelProtocol(() => this.endCommissioning());
     private activeCommissioningMode = AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen;
+    private activeCommissioningDiscriminator?: number;
     private activeCommissioningEndCallback?: () => void;
     private announceInterval: Timer;
     private announcementStartedTime: number | null = null;
@@ -115,6 +116,8 @@ export class MatterDevice {
                 // Last fabric got removed, so expire all announcements
                 await this.expireAllFabricAnnouncements();
             }
+            // If a commissioning window is open then we reannounce this because it was ended as fabric got added
+            this.reAnnounceAsCommissionable();
         });
         this.#fabricManager.events.updated.on(({ fabricIndex }) =>
             this.commissioningChangedCallback(fabricIndex, FabricAction.Updated),
@@ -143,18 +146,25 @@ export class MatterDevice {
                 // Delayed closing is executed when exchange is closed
                 await this.exchangeManager.closeSession(session);
             }
-            const currentFabric = session.fabric;
-            if (currentFabric !== undefined) {
-                this.sessionChangedCallback(currentFabric.fabricIndex);
+
+            const currentFabricIndex = session.fabric?.fabricIndex;
+            if (currentFabricIndex !== undefined) {
+                this.sessionChangedCallback(currentFabricIndex);
             }
+
             if (this.isClosing) {
                 return;
             }
+
+            // Verify if the session associated fabric still exists
+            const existingSessionFabric =
+                currentFabricIndex === undefined ? undefined : this.getFabricByIndex(currentFabricIndex)?.fabricIndex;
+
             // When a session closes, announce existing fabrics again so that controller can detect the device again.
             // When session was closed and no fabric exist anymore then this is triggering a factory reset in upper layer
             // and it would be not good to announce a commissionable device and then reset that again with the factory reset
-            if (this.#fabricManager.getFabrics().length > 0 || !currentFabric) {
-                await this.startAnnouncement();
+            if (this.#fabricManager.getFabrics().length > 0 || session.isPase || !existingSessionFabric) {
+                this.startAnnouncement().catch(error => logger.warn(`Error while announcing`, error));
             }
         });
 
@@ -293,7 +303,7 @@ export class MatterDevice {
 
     async expireAllFabricAnnouncements() {
         for (const broadcaster of this.broadcasters) {
-            await broadcaster.expireAllAnnouncements();
+            await broadcaster.expireFabricAnnouncement();
         }
     }
 
@@ -328,7 +338,10 @@ export class MatterDevice {
             }
             for (const broadcaster of this.broadcasters) {
                 await broadcaster.setFabrics(fabrics);
-                if (fabricsWithoutSessions > 0) {
+                if (
+                    fabricsWithoutSessions > 0 ||
+                    this.activeCommissioningMode !== AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen
+                ) {
                     await broadcaster.announce();
                 }
             }
@@ -354,6 +367,7 @@ export class MatterDevice {
             throw new InternalError("Commissioning window already open with different callback!");
         }
         this.activeCommissioningMode = mode;
+        this.activeCommissioningDiscriminator = discriminator;
         if (activeCommissioningEndCallback !== undefined) {
             this.activeCommissioningEndCallback = activeCommissioningEndCallback;
         }
@@ -364,6 +378,15 @@ export class MatterDevice {
         );
     }
 
+    reAnnounceAsCommissionable() {
+        if (this.activeCommissioningMode === AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen) {
+            return;
+        }
+        this.sendCommissionableAnnouncement(this.activeCommissioningMode, this.activeCommissioningDiscriminator).catch(
+            error => logger.warn("Error sending announcement", error),
+        );
+    }
+
     async sendCommissionableAnnouncement(
         mode: AdministratorCommissioning.CommissioningWindowStatus,
         discriminator?: number,
@@ -504,8 +527,8 @@ export class MatterDevice {
         return { session, channel: await networkInterface.openChannel(device.addresses[0]) };
     }
 
-    async clearSubscriptionsForNode(peerNodeId: NodeId, flushSubscriptions?: boolean) {
-        await this.#sessionManager.clearSubscriptionsForNode(peerNodeId, flushSubscriptions);
+    async clearSubscriptionsForNode(fabricIndex: FabricIndex, peerNodeId: NodeId, flushSubscriptions?: boolean) {
+        await this.#sessionManager.clearSubscriptionsForNode(fabricIndex, peerNodeId, flushSubscriptions);
     }
 
     async close() {

package/src/behavior/AccessControl.ts

@@ -271,7 +271,7 @@ function dataEnforcerFor(schema: Schema): AccessControl {
                 }
 
                 if (location?.owningFabric && location.owningFabric !== session.fabric) {
-                    throw new WriteError(
+                    throw new ReadError(
                         location,
                         "Permission denied: Owning/accessing fabric mismatch",
                         StatusCode.UnsupportedAccess,
@@ -291,7 +291,7 @@ function dataEnforcerFor(schema: Schema): AccessControl {
                 return false;
             }
 
-            if (session.fabricFiltered && location?.owningFabric && location.owningFabric !== session.fabric) {
+            if (location?.owningFabric && location.owningFabric !== session.fabric) {
                 return false;
             }
 

package/src/behavior/definitions/general-commissioning/ServerNodeFailsafeContext.ts

@@ -5,9 +5,10 @@
  */
 
 import { FailsafeContext } from "../../../common/FailsafeContext.js";
-import { Lifecycle } from "../../../common/Lifecycle.js";
+import { Lifecycle, UnsupportedDependencyError } from "../../../common/Lifecycle.js";
 import { Endpoint } from "../../../endpoint/Endpoint.js";
 import { Fabric } from "../../../fabric/Fabric.js";
+import { FabricManager } from "../../../fabric/FabricManager.js";
 import { Node } from "../../../node/Node.js";
 import { Immutable } from "../../../util/Type.js";
 import { NetworkCommissioningBehavior } from "../network-commissioning/NetworkCommissioningBehavior.js";
@@ -101,6 +102,25 @@ export class ServerNodeFailsafeContext extends FailsafeContext {
         });
     }
 
+    override async rollback() {
+        if (!this.fabricIndex && this.hasRootCert) {
+            // Update the fabric details if needed (like Trusted Root certificates)
+            // Only if fabric was not added because else all data gets updated anyway
+            try {
+                const fabricManager = this.#node.env.get(FabricManager);
+                fabricManager.events.failsafeClosed.emit();
+            } catch (error) {
+                // UnsupportedDependencyError can happen when the node closes.
+                // Then data are refreshed on next start anyway, so ignore this case
+                if (!(error instanceof UnsupportedDependencyError)) {
+                    throw error;
+                }
+            }
+        }
+
+        return super.rollback();
+    }
+
     /*
     override async restoreFabric() {
         await super.restoreFabric();

package/src/behavior/definitions/operational-credentials/OperationalCredentialsServer.ts

@@ -12,6 +12,7 @@ import { MatterFabricInvalidAdminSubjectError } from "../../../common/FailsafeCo
 import { MatterFabricConflictError } from "../../../common/FailsafeTimer.js";
 import { MatterFlowError, UnexpectedDataError } from "../../../common/MatterError.js";
 import { ValidationError } from "../../../common/ValidationError.js";
+import { CryptoVerifyError } from "../../../crypto/Crypto.js";
 import { FabricIndex } from "../../../datatype/FabricIndex.js";
 import { Endpoint } from "../../../endpoint/Endpoint.js";
 import { Fabric, PublicKeyError } from "../../../fabric/Fabric.js";
@@ -169,6 +170,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
                 debugText: error.message,
             };
         } else if (
+            error instanceof CryptoVerifyError ||
             error instanceof CertificateError ||
             error instanceof ValidationError ||
             error instanceof UnexpectedDataError
@@ -411,6 +413,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
         } catch (error) {
             logger.info("setting root certificate failed", error);
             if (
+                error instanceof CryptoVerifyError ||
                 error instanceof CertificateError ||
                 error instanceof ValidationError ||
                 error instanceof UnexpectedDataError
@@ -419,6 +422,11 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             }
             throw error;
         }
+
+        const fabrics = this.endpoint.env.get(FabricManager).getFabrics();
+        const trustedRootCertificates = fabrics.map(fabric => fabric.rootCert);
+        trustedRootCertificates.push(rootCaCertificate);
+        this.state.trustedRootCertificates = trustedRootCertificates;
     }
 
     async #updateFabrics() {
@@ -474,11 +482,16 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
         this.agent.get(CommissioningBehavior).handleFabricChange(fabricIndex, FabricAction.Removed);
     }
 
+    async #handleFailsafeClosed() {
+        await this.#updateFabrics();
+    }
+
     async #nodeOnline() {
         const fabricManager = this.endpoint.env.get(FabricManager);
         this.reactTo(fabricManager.events.added, this.#handleAddedFabric);
         this.reactTo(fabricManager.events.updated, this.#handleUpdatedFabric);
         this.reactTo(fabricManager.events.deleted, this.#handleRemovedFabric);
+        this.reactTo(fabricManager.events.failsafeClosed, this.#handleFailsafeClosed, { lock: true });
         await this.#updateFabrics();
     }
 }

package/src/certificate/CertificateManager.ts

@@ -800,8 +800,7 @@ export class CertificateManager {
             );
         }
 
-        // Root cert is self signed anyway, so we do not need to verify it with itself
-        //Crypto.verify(PublicKey(rootCert.ellipticCurvePublicKey), this.rootCertToAsn1(rootCert), rootCert.signature);
+        Crypto.verify(PublicKey(rootCert.ellipticCurvePublicKey), this.rootCertToAsn1(rootCert), rootCert.signature);
     }
 
     /**

package/src/certificate/CertificationDeclarationManager.ts

@@ -31,7 +31,7 @@ const TestCMS_SignerPrivateKey = ByteArray.fromHex("AEF3484116E9481EC57BE0472DF4
 const TestCMS_SignerSubjectKeyIdentifier = ByteArray.fromHex("62FA823359ACFAA9963E1CFA140ADDF504F37160");
 
 export class CertificationDeclarationManager {
-    static generate(vendorId: VendorId, productId: number) {
+    static generate(vendorId: VendorId, productId: number, provisional = false) {
         const certificationElements = TlvCertificationDeclaration.encode({
             formatVersion: 1,
             vendorId,
@@ -41,7 +41,7 @@ export class CertificationDeclarationManager {
             securityLevel: 0,
             securityInformation: 0,
             versionNumber: 1,
-            certificationType: 0,
+            certificationType: provisional ? 1 : 0, // 0 = Test, 1 = Provisional/In certification, 2 = official
         });
 
         return CertificateManager.CertificationDeclarationToAsn1(

package/src/cluster/server/AccessControlServer.ts

@@ -28,16 +28,16 @@ import {
 } from "./AttributeServer.js";
 import { ClusterServer } from "./ClusterServer.js";
 import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-import { EventServer } from "./EventServer.js";
+import { FabricSensitiveEventServer } from "./EventServer.js";
 
 const logger = Logger.get("AccessControlClusterServer");
 
 export const AccessControlClusterHandler: () => ClusterServerHandlers<typeof AccessControlCluster> = () => {
     let accessControlEntryChangedEvent:
-        | EventServer<AccessControl.AccessControlEntryChangedEvent, SyncStorage>
+        | FabricSensitiveEventServer<AccessControl.AccessControlEntryChangedEvent, SyncStorage>
         | undefined = undefined;
     let accessControlExtensionChangedEvent:
-        | EventServer<AccessControl.AccessControlExtensionChangedEvent, SyncStorage>
+        | FabricSensitiveEventServer<AccessControl.AccessControlExtensionChangedEvent, SyncStorage>
         | undefined = undefined;
 
     return {

package/src/cluster/server/AttributeServer.ts

@@ -13,7 +13,13 @@ import { AttributeId } from "../../datatype/AttributeId.js";
 import { Endpoint as EndpointInterface } from "../../device/Endpoint.js";
 import { Fabric } from "../../fabric/Fabric.js";
 import { Logger } from "../../log/Logger.js";
-import { Globals } from "../../model/index.js";
+import {
+    AttributeModel,
+    ClusterModel,
+    DatatypeModel,
+    Globals,
+    MatterModel as MatterModelObj,
+} from "../../model/index.js";
 import { StatusCode, StatusResponseError } from "../../protocol/interaction/StatusCode.js";
 import { BitSchema, TypeFromPartialBitSchema } from "../../schema/BitmapSchema.js";
 import { NoAssociatedFabricError, SecureSession, assertSecureSession } from "../../session/SecureSession.js";
@@ -21,11 +27,15 @@ import { Session } from "../../session/Session.js";
 import { TlvSchema } from "../../tlv/TlvSchema.js";
 import { isDeepEqual } from "../../util/DeepEqual.js";
 import { MaybePromise } from "../../util/Promises.js";
+import { camelize } from "../../util/String.js";
 import { AccessLevel, Attribute, Attributes, Cluster, Commands, Events } from "../Cluster.js";
 import { ClusterDatasource } from "./ClusterServerTypes.js";
 
 const logger = Logger.get("AttributeServer");
 
+const FabricIndexName = "fabricIndex";
+const MatterModel = new MatterModelObj();
+
 /**
  * Thrown when an operation cannot complete because fabric information is
  * unavailable.
@@ -178,6 +188,10 @@ export abstract class BaseAttributeServer<T> {
         this.defaultValue = this.value;
     }
 
+    get hasFabricSensitiveData() {
+        return false;
+    }
+
     validateWithSchema(value: T) {
         try {
             this.schema.validate(value);
@@ -727,6 +741,7 @@ export function genericFabricScopedAttributeSetter<T>(
 export class FabricScopedAttributeServer<T> extends AttributeServer<T> {
     private readonly isCustomGetter: boolean;
     private readonly isCustomSetter: boolean;
+    private readonly fabricSensitiveElementsToRemove = new Array<string>();
 
     constructor(
         id: AttributeId,
@@ -814,6 +829,69 @@ export class FabricScopedAttributeServer<T> extends AttributeServer<T> {
         );
         this.isCustomGetter = isCustomGetter;
         this.isCustomSetter = isCustomSetter;
+
+        this.#determineSensitiveFieldsToRemove();
+    }
+
+    #determineSensitiveFieldsToRemove() {
+        const clusterFromModel = MatterModel.get(ClusterModel, this.cluster.id);
+        if (clusterFromModel === undefined) {
+            logger.debug(`${this.cluster.name}: Cluster for Fabric scoped element not found in Model, ignore`);
+            return;
+        }
+        const attributeFromModel = clusterFromModel.get(AttributeModel, this.id);
+        if (attributeFromModel === undefined) {
+            logger.debug(
+                `${this.cluster.name}.${this.id}: Attribute for Fabric scoped element not found in Model, ignore`,
+            );
+            return;
+        }
+        if (!attributeFromModel.fabricScoped) {
+            logger.debug(`${this.cluster.name}.${this.id}: Attribute is not Fabric scoped in model, ignore`);
+            return;
+        }
+        if (attributeFromModel.children.length !== 1) {
+            logger.debug(`${this.cluster.name}.${this.id}: Attribute has not exactly one child, ignore`);
+            return;
+        }
+        const type = attributeFromModel.children[0].type;
+        if (type === undefined) {
+            logger.debug(`${this.cluster.name}.${this.id}: Attribute field has no type, ignore`);
+            return;
+        }
+        const dataType = clusterFromModel.get(DatatypeModel, type);
+        if (dataType === undefined) {
+            logger.debug(`${this.cluster.name}.${this.id}: DataType ${type} not found in model, ignore`);
+            return;
+        }
+        dataType.children
+            .filter(field => field.fabricSensitive)
+            .forEach(field => this.fabricSensitiveElementsToRemove.push(camelize(field.name)));
+    }
+
+    override get hasFabricSensitiveData() {
+        return this.fabricSensitiveElementsToRemove.length > 0;
+    }
+
+    /**
+     * Sanitize the value of the attribute by removing fabric sensitive fields that do not belong to the
+     * associated fabric
+     */
+    sanitizeFabricSensitiveFields(value: T, associatedFabric?: Fabric) {
+        if (this.fabricSensitiveElementsToRemove.length && Array.isArray(value)) {
+            // Get the associated Fabric Index or uses -1 when no Fabric is associated because this value will
+            // never be in the struct
+            const associatedFabricIndex = associatedFabric?.fabricIndex ?? -1;
+            return value.map(data => {
+                if (data[FabricIndexName] !== associatedFabricIndex) {
+                    const result = { ...data };
+                    this.fabricSensitiveElementsToRemove.forEach(fieldName => delete result[fieldName]);
+                    return result;
+                }
+                return data;
+            });
+        }
+        return value;
     }
 
     /**

package/src/cluster/server/ClusterServer.ts

@@ -37,7 +37,7 @@ import {
     SupportedEventsList,
 } from "./ClusterServerTypes.js";
 import { CommandServer } from "./CommandServer.js";
-import { EventServer } from "./EventServer.js";
+import { createEventServer } from "./EventServer.js";
 
 const logger = Logger.get("ClusterServer");
 
@@ -508,7 +508,14 @@ export function ClusterServer<
         }
 
         if ((supportedEvents as any)[eventName] === true) {
-            (events as any)[eventName] = new EventServer(id, clusterId, eventName, schema, priority, readAcl);
+            (events as any)[eventName] = createEventServer(
+                clusterDef,
+                eventDef[eventName],
+                eventName,
+                schema,
+                priority,
+                readAcl,
+            );
             const capitalizedEventName = capitalize(eventName);
             result[`trigger${capitalizedEventName}Event`] = <T>(event: T) =>
                 (events as any)[eventName].triggerEvent(event);

package/src/cluster/server/ClusterServerTypes.ts

@@ -49,7 +49,7 @@ import {
 import { Scenes } from "../definitions/ScenesCluster.js";
 import { AttributeServer, FabricScopedAttributeServer, FixedAttributeServer } from "./AttributeServer.js";
 import { CommandServer } from "./CommandServer.js";
-import { EventServer } from "./EventServer.js";
+import { AnyEventServer } from "./EventServer.js";
 
 /** Cluster attributes accessible on the cluster server */
 type MandatoryAttributeServers<A extends Attributes> = Omit<
@@ -243,8 +243,8 @@ type ServerAttributeSubscribers<A extends Attributes> = {
 };
 
 export type EventServers<E extends Events> = Merge<
-    { [P in MandatoryEventNames<E>]: EventServer<EventType<E[P]>, any> },
-    { [P in OptionalEventNames<E>]?: EventServer<EventType<E[P]>, any> }
+    { [P in MandatoryEventNames<E>]: AnyEventServer<EventType<E[P]>, any> },
+    { [P in OptionalEventNames<E>]?: AnyEventServer<EventType<E[P]>, any> }
 >;
 type ServerEventTriggers<E extends Events> = {
     [P in MandatoryEventNames<E> as `trigger${Capitalize<string & P>}Event`]: (event: EventType<E[P]>) => void;