@matter/node 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/behaviors/general-diagnostics/GeneralDiagnosticsInterface.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MaybePromise } from "#general";
+import { GeneralDiagnostics } from "#clusters/general-diagnostics";
+
+export namespace GeneralDiagnosticsInterface {
+    export interface Base {
+        /**
+         * This command shall be supported to provide a means for certification tests to trigger some test-
+         * plan-specific events, necessary to assist in automation of device interactions for some certification test
+         * cases. This command shall NOT cause any changes to the state of the device that persist after the last
+         * fabric is removed.
+         *
+         * The fields for the TestEventTrigger command are as follows:
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.12.7.1
+         */
+        testEventTrigger(request: GeneralDiagnostics.TestEventTriggerRequest): MaybePromise;
+
+        /**
+         * This command may be used by a client to obtain a correlated view of both System Time, and, if currently
+         * synchronized and supported, "wall clock time" of the server. This can help clients establish
+         *
+         * time correlation between their concept of time and the server’s concept of time. This is especially useful
+         * when processing event histories where some events only contain System Time.
+         *
+         * Upon command invocation, the server shall respond with a TimeSnapshotResponse.
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.12.7.2
+         */
+        timeSnapshot(): MaybePromise<GeneralDiagnostics.TimeSnapshotResponse>;
+    }
+
+    export interface DataModelTest {
+        /**
+         * This command provides a means for certification tests or manufacturer’s internal tests to validate
+         * particular command handling and encoding constraints by generating a response of a given size.
+         *
+         * This command shall use the same EnableKey behavior as the TestEventTrigger command, whereby processing of
+         * the command is only enabled when the TestEventTriggersEnabled field is true, which shall NOT be true outside
+         * of certification testing or manufacturer’s internal tests.
+         *
+         * The fields for the PayloadTestRequest command are as follows:
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.12.7.4
+         */
+        payloadTestRequest(request: GeneralDiagnostics.PayloadTestRequest): MaybePromise<GeneralDiagnostics.PayloadTestResponse>;
+    }
+}
+
+export type GeneralDiagnosticsInterface = {
+    components: [
+        { flags: {}, methods: GeneralDiagnosticsInterface.Base },
+        { flags: { dataModelTest: true }, methods: GeneralDiagnosticsInterface.DataModelTest }
+    ]
+};

package/src/behaviors/general-diagnostics/GeneralDiagnosticsServer.ts

@@ -0,0 +1,440 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Val } from "#behavior/state/Val.js";
+import { ValueSupervisor } from "#behavior/supervision/ValueSupervisor.js";
+import { NetworkServer } from "#behavior/system/network/NetworkServer.js";
+import { NetworkCommissioningServer } from "#behaviors/network-commissioning";
+import { GeneralDiagnostics } from "#clusters/general-diagnostics";
+import { Endpoint } from "#endpoint/Endpoint.js";
+import { Bytes, ImplementationError, ipv4ToBytes, Logger, Time, Timer } from "#general";
+import { FieldElement, Specification } from "#model";
+import { NodeLifecycle } from "#node/NodeLifecycle.js";
+import { MdnsService } from "#protocol";
+import { CommandId, StatusCode, StatusResponseError, TlvInvokeResponse } from "#types";
+import { GeneralDiagnosticsBehavior } from "./GeneralDiagnosticsBehavior.js";
+
+const logger = Logger.get("GeneralDiagnosticsServer");
+
+// Enable DataModelTest feature by default because we use MaxPathsPerInvoke > 1 by default
+const Base = GeneralDiagnosticsBehavior.with(GeneralDiagnostics.Feature.DataModelTest);
+
+// Enhance the Schema to store the real operational hours counter we internally use and persist this
+const schema = Base.schema!.extend({
+    children: [FieldElement({ name: "totalOperationalHoursCounter", type: "uint64", quality: "N" })],
+});
+
+/**
+ * This is the default server implementation of GeneralDiagnosticsBehavior.
+ *
+ * The implementation provides convenience methods to register and clear hardware, radio, and network faults and to
+ * handle test Event triggers.
+ *
+ * To handle test Event triggers please override the triggerTestEvent method. If these test events are used in
+ * certification please also set the EnableKey in the enhanced state as `deviceTestEnableKey`.
+ *
+ * To register or clear hardware, radio, and network faults, please use the provided convenience methods:
+ * * registerHardwareFault and clearHardwareFault
+ * * registerRadioFault and clearRadioFault
+ * * registerNetworkFault and clearNetworkFault
+ * If you want to send events when faults are registered or cleared you need to enable these events when the Root
+ * Endpoint gets initialized.
+ */
+export class GeneralDiagnosticsServer extends Base {
+    protected declare internal: GeneralDiagnosticsServer.Internal;
+    declare state: GeneralDiagnosticsServer.State;
+    schema = schema;
+
+    override initialize() {
+        if (this.state.testEventTriggersEnabled === undefined) {
+            this.state.testEventTriggersEnabled = false;
+        } else if (this.state.testEventTriggersEnabled) {
+            if (this.state.deviceTestEnableKey.every(byte => byte === 0)) {
+                throw new ImplementationError("Test event triggers are enabled but no deviceTestEnableKey is set.");
+            }
+            logger.warn("Test event triggers are enabled. Make sure to disable them in production.");
+        }
+
+        if (this.state.rebootCount === undefined) {
+            this.state.rebootCount = 0;
+        } else {
+            this.state.rebootCount++;
+        }
+
+        const lifecycle = this.endpoint.lifecycle as NodeLifecycle;
+
+        if (lifecycle.online !== undefined) {
+            this.reactTo(lifecycle.online, this.#online, { lock: true });
+        }
+
+        if (this.events.activeHardwareFaults$Changed !== undefined) {
+            this.reactTo(this.events.activeHardwareFaults$Changed, this.#triggerActiveHardwareFaultsChangedEvent);
+        }
+        if (this.events.activeRadioFaults$Changed !== undefined) {
+            this.reactTo(this.events.activeRadioFaults$Changed, this.#triggerActiveRadioFaultsChangedEvent);
+        }
+        if (this.events.activeNetworkFaults$Changed !== undefined) {
+            this.reactTo(this.events.activeNetworkFaults$Changed, this.#triggerActiveNetworkFaultsChangedEvent);
+        }
+    }
+
+    #validateTestEnabledKey(enableKey: Uint8Array) {
+        if (enableKey.every(byte => byte === 0)) {
+            throw new StatusResponseError("Invalid test enable key, all zeros", StatusCode.ConstraintError);
+        }
+        enableKey.forEach((byte, index) => {
+            if (byte !== this.state.deviceTestEnableKey[index]) {
+                throw new StatusResponseError("Invalid test enable key", StatusCode.ConstraintError);
+            }
+        });
+    }
+
+    override testEventTrigger({ eventTrigger, enableKey }: GeneralDiagnostics.TestEventTriggerRequest) {
+        this.#validateTestEnabledKey(enableKey);
+
+        this.triggerTestEvent(eventTrigger);
+    }
+
+    protected triggerTestEvent(eventTrigger: number | bigint) {
+        throw new StatusResponseError(`Unsupported test event trigger ${eventTrigger}`, StatusCode.InvalidCommand);
+    }
+
+    override timeSnapshot() {
+        const time = Time.nowMs();
+        return {
+            systemTimeMs: time - this.internal.bootUpTime,
+            posixTimeMs: time,
+        };
+    }
+
+    override payloadTestRequest({
+        enableKey,
+        value,
+        count,
+    }: GeneralDiagnostics.PayloadTestRequest): GeneralDiagnostics.PayloadTestResponse {
+        this.#validateTestEnabledKey(enableKey);
+
+        if (!this.state.testEventTriggersEnabled) {
+            throw new StatusResponseError("Test event triggers are disabled", StatusCode.ConstraintError);
+        }
+
+        const payload = new Uint8Array(count).fill(value);
+
+        // In our case encoding is done completely on an upper layer, so we need to build a dummy single response to get the size
+        // Formal note: This is not 100% accurate and we might be some bytes to huge (moreChunkedMessages, commandRef)
+        // but near enough
+        const responseSize = TlvInvokeResponse.encode({
+            suppressResponse: false,
+            interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
+            moreChunkedMessages: true,
+            invokeResponses: [
+                {
+                    command: {
+                        commandPath: {
+                            endpointId: this.endpoint.number,
+                            clusterId: GeneralDiagnostics.Complete.id,
+                            commandId: CommandId(0x04), // Hardcode for now
+                        },
+                        commandRef: 0,
+                        commandFields: GeneralDiagnostics.TlvPayloadTestResponse.encodeTlv({
+                            payload,
+                        }),
+                    },
+                },
+            ],
+        }).length;
+
+        const exchange = this.context.exchange;
+        if (exchange === undefined) {
+            throw new ImplementationError(`Illegal operation outside exchange context`);
+        }
+
+        if (responseSize > exchange.maxPayloadSize) {
+            throw new StatusResponseError("Response too large", StatusCode.ResourceExhausted);
+        }
+
+        return {
+            payload,
+        };
+    }
+
+    /**
+     * Register a hardware fault. This convenience method updates the activeHardwareFaults attribute and sends out the
+     * HardwareFaultChanged event. Make sure to clear the fault when it is resolved.
+     * This method requires that the activeHardwareFaults attribute is activated when the cluster gets initialized.
+     *
+     * @param faultType The hardware fault to register.
+     */
+    registerHardwareFault(faultType: GeneralDiagnostics.HardwareFault) {
+        const currentFaults = this.requireAttributeEnabled("activeHardwareFaults");
+        const list = currentFaults.filter(fault => fault !== faultType);
+        list.push(faultType);
+        this.state.activeHardwareFaults = list;
+    }
+
+    /**
+     * Clear a hardware fault. This convenience method updates the activeHardwareFaults attribute and sends out the
+     * HardwareFaultChanged event.
+     *
+     * @param faultType The hardware fault to clear.
+     */
+    clearHardwareFault(faultType: GeneralDiagnostics.HardwareFault) {
+        const currentFaults = this.requireAttributeEnabled("activeHardwareFaults");
+        this.state.activeHardwareFaults = currentFaults.filter(fault => fault !== faultType);
+    }
+
+    #triggerActiveHardwareFaultsChangedEvent(
+        current: GeneralDiagnostics.HardwareFault[],
+        previous: GeneralDiagnostics.HardwareFault[],
+    ) {
+        this.events.hardwareFaultChange?.emit(
+            {
+                current,
+                previous,
+            },
+            this.context,
+        );
+    }
+
+    /**
+     * Register a radio fault. This convenience method updates the activeRadioFaults attribute and sends out the
+     * RadioFaultChanged event. Make sure to clear the fault when it is resolved.
+     * This method requires that the activeRadioFaults attribute is activated when the cluster gets initialized.
+     *
+     * @param faultType The radio fault to register.
+     */
+    registerRadioFault(faultType: GeneralDiagnostics.RadioFault) {
+        const currentFaults = this.requireAttributeEnabled("activeRadioFaults");
+        const list = currentFaults.filter(fault => fault !== faultType);
+        list.push(faultType);
+        this.state.activeRadioFaults = list;
+    }
+
+    /**
+     * Clear a radio fault. This convenience method updates the activeRadioFaults attribute and sends out the
+     * RadioFaultChanged event.
+     *
+     * @param faultType The radio fault to clear.
+     */
+    clearRadioFault(faultType: GeneralDiagnostics.RadioFault) {
+        const currentFaults = this.requireAttributeEnabled("activeRadioFaults");
+        this.state.activeRadioFaults = currentFaults.filter(fault => fault !== faultType);
+    }
+
+    #triggerActiveRadioFaultsChangedEvent(
+        current: GeneralDiagnostics.RadioFault[],
+        previous: GeneralDiagnostics.RadioFault[],
+    ) {
+        this.events.radioFaultChange?.emit(
+            {
+                current,
+                previous,
+            },
+            this.context,
+        );
+    }
+
+    /**
+     * Register a network fault. This convenience method updates the activeNetworkFaults attribute and sends out the
+     * NetworkFaultChanged event. Make sure to clear the fault when it is resolved.
+     * This method requires that the activeNetworkFaults attribute is activated when the cluster gets initialized.
+     *
+     * @param faultType The network fault to register.
+     */
+    registerNetworkFault(faultType: GeneralDiagnostics.NetworkFault) {
+        const currentFaults = this.requireAttributeEnabled("activeNetworkFaults");
+        const list = currentFaults.filter(fault => fault !== faultType);
+        list.push(faultType);
+        this.state.activeNetworkFaults = list;
+    }
+
+    /**
+     * Clear a network fault. This convenience method updates the activeNetworkFaults attribute and sends out the
+     * NetworkFaultChanged event.
+     *
+     * @param faultType The network fault to clear.
+     */
+    clearNetworkFault(faultType: GeneralDiagnostics.NetworkFault) {
+        const currentFaults = this.requireAttributeEnabled("activeNetworkFaults");
+        this.state.activeNetworkFaults = currentFaults.filter(fault => fault !== faultType);
+    }
+
+    #triggerActiveNetworkFaultsChangedEvent(
+        current: GeneralDiagnostics.NetworkFault[],
+        previous: GeneralDiagnostics.NetworkFault[],
+    ) {
+        this.events.networkFaultChange?.emit(
+            {
+                current,
+                previous,
+            },
+            this.context,
+        );
+    }
+
+    async #online() {
+        this.events.bootReason.emit(
+            { bootReason: this.state.bootReason ?? GeneralDiagnostics.BootReason.Unspecified },
+            this.context,
+        );
+
+        // Update the timestamps now that node is really online.
+        this.internal.bootUpTime = Time.nowMs();
+        this.internal.lastTotalOperationalHoursCounterUpdateTime = Time.nowMs();
+
+        this.internal.lastTotalOperationalHoursTimer = Time.getPeriodicTimer(
+            "GeneralDiagnostics.operationalHours",
+            5 * 60_000,
+            this.callback(this.#updateTotalOperationalHoursCounter),
+        ).start();
+
+        await this.#updateNetworkList();
+    }
+
+    #updateTotalOperationalHoursCounter() {
+        const now = Time.nowMs();
+        const elapsedTime = now - this.internal.lastTotalOperationalHoursCounterUpdateTime;
+        this.state.totalOperationalHoursCounter = this.state.totalOperationalHoursCounter + elapsedTime;
+        this.internal.lastTotalOperationalHoursCounterUpdateTime = now;
+    }
+
+    async #updateNetworkList() {
+        const mdnsService = this.env.get(MdnsService);
+        const mdnsLimitedToNetworkInterfaces = mdnsService.limitedToNetInterface;
+
+        const networkRuntime = this.endpoint.behaviors.internalsOf(NetworkServer).runtime;
+        const systemNetworkInterfaces = await networkRuntime.getNetworkInterfaces();
+
+        // Determine the network type for all interfaces based on the Network Commissioning Server on the root endpoint
+        // TODO: Find a way if needed to handle devices connected with multiple technologies and report that correctly
+        //       but irrelevant for now because noone expects that (including chip)
+        let networkType = GeneralDiagnostics.InterfaceType.Ethernet;
+        if (this.endpoint.behaviors.has(NetworkCommissioningServer)) {
+            const networkCommissioning = this.agent.get(NetworkCommissioningServer);
+            if (
+                "wiFiNetworkInterface" in networkCommissioning.features &&
+                networkCommissioning.features.wiFiNetworkInterface
+            ) {
+                networkType = GeneralDiagnostics.InterfaceType.WiFi;
+            } else if (
+                "threadNetworkInterface" in networkCommissioning.features &&
+                networkCommissioning.features.threadNetworkInterface
+            ) {
+                networkType = GeneralDiagnostics.InterfaceType.Thread;
+            }
+        }
+
+        // If we only announce on one network interface, also consider this onw as only operational one (because noone
+        // else should connect to the others even if we listen
+        const isOperationalReachable =
+            mdnsLimitedToNetworkInterfaces === undefined
+                ? () => true
+                : (name: string) => {
+                      return name === mdnsLimitedToNetworkInterfaces;
+                  };
+
+        // Filter all unassigned MACs out, sort operational on top, limit to 8 entries and map to the required format.
+        this.state.networkInterfaces = systemNetworkInterfaces
+            .filter(({ mac }) => mac !== "00:00:00:00:00:00")
+            .sort(({ name: nameA }, { name: nameB }) => {
+                // sort operational entries on top, others to bottom
+                if (isOperationalReachable(nameA) && !isOperationalReachable(nameB)) {
+                    return -1;
+                }
+                if (!isOperationalReachable(nameA) && isOperationalReachable(nameB)) {
+                    return 1;
+                }
+                return 0;
+            })
+            .slice(0, 8)
+            .map(({ name, mac, ipV4, ipV6, type }) => ({
+                name,
+                isOperational: isOperationalReachable(name),
+                offPremiseServicesReachableIPv4: null, // null means unknown or not supported
+                offPremiseServicesReachableIPv6: null, // null means unknown or not supported
+                hardwareAddress: Bytes.fromHex(mac.replace(/[^\da-fA-F]/g, "")),
+                iPv4Addresses: ipV4.slice(0, 4).map(ip => ipv4ToBytes(ip)),
+                iPv6Addresses: ipV6.slice(0, 8).map(ip => ipv4ToBytes(ip)),
+                type: type ?? networkType,
+            }));
+    }
+
+    override async [Symbol.asyncDispose]() {
+        this.internal.lastTotalOperationalHoursTimer?.stop();
+        this.#updateTotalOperationalHoursCounter();
+        await super[Symbol.asyncDispose]?.();
+    }
+}
+
+export namespace GeneralDiagnosticsServer {
+    export class Internal {
+        /** Remember the bootUp time for the device. */
+        bootUpTime: number = Time.nowMs();
+
+        /** Last time the total operational hours counter was updated. */
+        lastTotalOperationalHoursCounterUpdateTime: number = Time.nowMs();
+
+        /** Timer to update the total operational hours counter every 5 minutes. */
+        lastTotalOperationalHoursTimer: Timer | undefined;
+    }
+
+    export class State extends Base.State {
+        /** Internal counter of the total operational hours, counted in seconds, updated every 5 minutes. */
+        totalOperationalHoursCounter: number = 0;
+
+        /** The TestEnableKey set for this device for the test commands. Default means "not enabled"." */
+        deviceTestEnableKey = new Uint8Array(16).fill(0);
+
+        [Val.properties](endpoint: Endpoint, _session: ValueSupervisor.Session) {
+            return {
+                /**
+                 * Dynamically calculate the upTime. This is ok because the attribute is not send out via subscriptions
+                 * anyway.
+                 */
+                get upTime() {
+                    const bootUpTime = endpoint.behaviors.internalsOf(GeneralDiagnosticsServer).bootUpTime;
+                    return Math.round((Time.nowMs() - bootUpTime) / 1000);
+                },
+
+                /**
+                 * Dynamically calculate the operating Hours from our internal counter. This is ok because the attribute
+                 * is not send out via subscriptions anyway.
+                 */
+                get totalOperationalHours() {
+                    const lastTotalOperationalHoursCounterUpdateTime =
+                        endpoint.behaviors.internalsOf(
+                            GeneralDiagnosticsServer,
+                        ).lastTotalOperationalHoursCounterUpdateTime;
+                    const totalOperationalHoursCounter =
+                        endpoint.stateOf(GeneralDiagnosticsServer).totalOperationalHoursCounter;
+                    return Math.floor(
+                        (Time.nowMs() - lastTotalOperationalHoursCounterUpdateTime + totalOperationalHoursCounter) /
+                            (60 * 60_000),
+                    );
+                },
+            };
+        }
+    }
+
+    export declare const ExtensionInterface: {
+        triggerTestEvent: (eventTrigger: number | bigint) => void;
+        registerHardwareFault: (
+            current: GeneralDiagnostics.HardwareFault[],
+            previous: GeneralDiagnostics.HardwareFault[],
+        ) => void;
+        registerRadioFault: (
+            current: GeneralDiagnostics.RadioFault[],
+            previous: GeneralDiagnostics.RadioFault[],
+        ) => void;
+        registerNetworkFault: (
+            current: GeneralDiagnostics.NetworkFault[],
+            previous: GeneralDiagnostics.NetworkFault[],
+        ) => void;
+        clearHardwareFault: (faultType: GeneralDiagnostics.HardwareFault) => void;
+        clearRadioFault: (faultType: GeneralDiagnostics.RadioFault) => void;
+        clearNetworkFault: (faultType: GeneralDiagnostics.NetworkFault) => void;
+    };
+}

package/src/behaviors/general-diagnostics/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
+
+export * from "./GeneralDiagnosticsInterface.js";
+export * from "./GeneralDiagnosticsBehavior.js";
+export * from "./GeneralDiagnosticsServer.js";

package/src/behaviors/group-key-management/GroupKeyManagementBehavior.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { GroupKeyManagement } from "#clusters/group-key-management";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { GroupKeyManagementInterface } from "./GroupKeyManagementInterface.js";
+
+/**
+ * GroupKeyManagementBehavior is the base class for objects that support interaction with {@link
+ * GroupKeyManagement.Cluster}.
+ */
+export const GroupKeyManagementBehavior = ClusterBehavior
+    .withInterface<GroupKeyManagementInterface>()
+    .for(GroupKeyManagement.Cluster);
+
+type GroupKeyManagementBehaviorType = InstanceType<typeof GroupKeyManagementBehavior>;
+export interface GroupKeyManagementBehavior extends GroupKeyManagementBehaviorType {}
+type StateType = InstanceType<typeof GroupKeyManagementBehavior.State>;
+export namespace GroupKeyManagementBehavior { export interface State extends StateType {} }

package/src/behaviors/group-key-management/GroupKeyManagementInterface.ts

@@ -0,0 +1,141 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MaybePromise } from "#general";
+import { GroupKeyManagement } from "#clusters/group-key-management";
+
+export namespace GroupKeyManagementInterface {
+    export interface Base {
+        /**
+         * This command is used by Administrators to set the state of a given Group Key Set, including atomically
+         * updating the state of all epoch keys.
+         *
+         * Effect on Receipt
+         *
+         * The following validations shall be done against the content of the GroupKeySet field:
+         *
+         *   • If the EpochKey0 field is null or its associated EpochStartTime0 field is null, then this command shall
+         *     fail with an INVALID_COMMAND status code responded to the client.
+         *
+         *   • If the EpochKey0 field’s length is not exactly 16 bytes, then this command shall fail with a
+         *     CONSTRAINT_ERROR status code responded to the client.
+         *
+         *   • If the EpochStartTime0 is set to 0, then this command shall fail with an INVALID_COMMAND status code
+         *     responded to the client. Note that internally, a GroupKeySetStruct’s EpochStartTime0 may be set to zero,
+         *     due to the behavior of the AddNOC command which synthesizes a GroupKeySetStruct (see IPKValue). However,
+         *     the value 0 is illegal in the GroupKeySet field sent by a client.
+         *
+         *   • If the EpochKey1 field is not null, then the EpochKey0 field shall NOT be null. Otherwise this command
+         *     shall fail with an INVALID_COMMAND status code responded to the client.
+         *
+         *   • If the EpochKey1 field is not null, and the field’s length is not exactly 16 bytes, then this command
+         *     shall fail with a CONSTRAINT_ERROR status code responded to the client.
+         *
+         *   • If the EpochKey1 field is not null, its associated EpochStartTime1 field shall NOT be null and shall
+         *     contain a later epoch start time than the epoch start time found in the EpochStartTime0 field. Otherwise
+         *     this command shall fail with an INVALID_COMMAND status code responded to the client.
+         *
+         *   • If exactly one of the EpochKey1 or EpochStartTime1 is null, rather than both being null, or neither
+         *     being null, then this command shall fail with an INVALID_COMMAND status code responded to the client.
+         *
+         *   • If the EpochKey2 field is not null, then the EpochKey1 and EpochKey0 fields shall NOT be null. Otherwise
+         *     this command shall fail with an INVALID_COMMAND status code responded to the client.
+         *
+         *   • If the EpochKey2 field is not null, and the field’s length is not exactly 16 bytes, then this command
+         *     shall fail with a CONSTRAINT_ERROR status code responded to the client.
+         *
+         *   • If the EpochKey2 field is not null, its associated EpochStartTime2 field shall NOT be null and shall
+         *     contain a later epoch start time than the epoch start time found in the EpochStartTime1 field. Otherwise
+         *     this command shall fail with an INVALID_COMMAND status code responded to the client.
+         *
+         *   • If exactly one of the EpochKey2 or EpochStartTime2 is null, rather than both being null, or neither
+         *     being null, then this command shall fail with an INVALID_COMMAND status code responded to the client.
+         *
+         * If there exists a Group Key Set associated with the accessing fabric which has the same GroupKeySetID as
+         * that provided in the GroupKeySet field, then the contents of that group key set shall be replaced. A
+         * replacement shall be done by executing the equivalent of entirely removing the previous Group Key Set with
+         * the given GroupKeySetID, followed by an addition of a Group Key Set with the provided configuration.
+         * Otherwise, if the GroupKeySetID did not match an existing entry, a new Group Key Set associated with the
+         * accessing fabric shall be created with the provided data. The Group Key Set shall be written to non-volatile
+         * storage.
+         *
+         * Upon completion, this command shall send a status code back to the initiator:
+         *
+         *   • If the Group Key Set was properly installed or updated on the Node, the status code shall be
+         *
+         * set to SUCCESS.
+         *
+         *   • If there are insufficient resources on the receiver to store an additional Group Key Set, the status
+         *     code shall be set to RESOURCE_EXHAUSTED (see group key limits);
+         *
+         *   • Otherwise, this status code shall be set to FAILURE.
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.2.7.1
+         */
+        keySetWrite(request: GroupKeyManagement.KeySetWriteRequest): MaybePromise;
+
+        /**
+         * This command is used by Administrators to read the state of a given Group Key Set.
+         *
+         * Effect on Receipt
+         *
+         * If there exists a Group Key Set associated with the accessing fabric which has the same GroupKeySetID as
+         * that provided in the GroupKeySetID field, then the contents of that Group Key Set shall be sent in a
+         * KeySetReadResponse command, but with the EpochKey0, EpochKey1 and EpochKey2 fields replaced by null.
+         *
+         * Otherwise, if the GroupKeySetID does not refer to a Group Key Set associated with the accessing fabric, then
+         * this command shall fail with a NOT_FOUND status code.
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.2.7.2
+         */
+        keySetRead(request: GroupKeyManagement.KeySetReadRequest): MaybePromise<GroupKeyManagement.KeySetReadResponse>;
+
+        /**
+         * This command is used by Administrators to remove all state of a given Group Key Set.
+         *
+         * Effect on Receipt
+         *
+         * If there exists a Group Key Set associated with the accessing fabric which has the same GroupKey
+         *
+         * SetID as that provided in the GroupKeySetID field, then the contents of that Group Key Set shall be removed,
+         * including all epoch keys it contains.
+         *
+         * If there exist any entries for the accessing fabric within the GroupKeyMap attribute that refer to the
+         * GroupKeySetID just removed, then these entries shall be removed from that list.
+         *
+         * This command shall fail with an INVALID_COMMAND status code back to the initiator if the GroupKeySetID being
+         * removed is 0, which is the Key Set associated with the Identity Protection Key (IPK). The only method to
+         * remove the IPK is usage of the RemoveFabric command or any operation which causes the equivalent of a
+         * RemoveFabric to occur by side-effect.
+         *
+         * This command shall send a SUCCESS status code back to the initiator on success, or NOT_FOUND if the
+         * GroupKeySetID requested did not exist.
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.2.7.4
+         */
+        keySetRemove(request: GroupKeyManagement.KeySetRemoveRequest): MaybePromise;
+
+        /**
+         * This command is used by Administrators to query a list of all Group Key Sets associated with the accessing
+         * fabric.
+         *
+         * NOTE Field 0 for this command is reserved and shall NOT be used.
+         *
+         * Effect on Receipt
+         *
+         * Upon receipt, this command shall iterate all stored GroupKeySetStruct associated with the accessing fabric
+         * and generate a KeySetReadAllIndicesResponse command containing the list of GroupKeySetID values from those
+         * structs.
+         *
+         * @see {@link MatterSpecification.v13.Core} § 11.2.7.5
+         */
+        keySetReadAllIndices(): MaybePromise<GroupKeyManagement.KeySetReadAllIndicesResponse>;
+    }
+}
+
+export type GroupKeyManagementInterface = { components: [{ flags: {}, methods: GroupKeyManagementInterface.Base }] };