@matterbridge/types 3.7.10 → 3.8.0-dev-20260524-eed6b4a

package/dist/matterClusterTypes.d.ts

@@ -0,0 +1,4366 @@
+import type { Bytes } from '@matter/general';
+import type { Semtag } from '@matter/types';
+import type { ClusterId, EndpointNumber, FabricIndex, GroupId, NodeId, SubjectId, VendorId } from '@matter/types/datatype';
+import type { Status } from '@matter/types/globals';
+export type EpochS = number;
+export type EpochUs = number | bigint;
+export type ElapsedS = number;
+export type Int64 = number | bigint;
+export type MatterEnum = number;
+export type MatterBitmap = number;
+export type MatterStruct = Record<string, unknown>;
+export type Percent = number;
+export type Percent100Ths = number;
+export type Temperature100Ths = number;
+export type SignedTemperature10Ths = number;
+export type UnsignedTemperature10Ths = number;
+export type ZoneId = number;
+export type TLSEndpointId = number;
+export type TLSCAId = number;
+export type TLSCCDId = number;
+export type WebRTCSessionId = number;
+export type PushTransportConnectionId = number;
+export type AudioStreamId = number;
+export type VideoStreamId = number;
+export type SnapshotStreamId = number;
+export type ModeId = number;
+export type SupportedModes = {
+    label: string;
+    mode: ModeId;
+    semanticTags: Semtag[];
+};
+export type LabelStruct = {
+    label: string;
+    value: string;
+};
+export type ClusterName = keyof MatterClusterTypes;
+export type ClusterFeatures<C extends ClusterName> = MatterClusterTypes[C]['features'];
+export type FeatureCode<C extends ClusterName> = keyof ClusterFeatures<C>;
+export type FeatureName<C extends ClusterName> = ClusterFeatures<C>[keyof ClusterFeatures<C>];
+export type ClusterAttributes<C extends ClusterName> = MatterClusterTypes[C]['attributes'];
+export type AttributeName<C extends ClusterName> = keyof ClusterAttributes<C>;
+export type ClusterCommands<C extends ClusterName> = MatterClusterTypes[C]['commands'];
+export type CommandName<C extends ClusterName> = keyof ClusterCommands<C>;
+export type ClusterEvents<C extends ClusterName> = MatterClusterTypes[C]['events'];
+export type EventName<C extends ClusterName> = keyof ClusterEvents<C>;
+export type MatterClusterTypes = {
+    'AccessControl': {
+        features: {
+            EXTS: 'Extension';
+            MNGD: 'ManagedDevice';
+        };
+        attributes: {
+            accessControlEntriesPerFabric: number;
+            acl: MatterStruct[];
+            arl: MatterStruct[];
+            commissioningArl: MatterStruct[];
+            extension: MatterStruct[];
+            subjectsPerAccessControlEntry: number;
+            targetsPerAccessControlEntry: number;
+        };
+        commands: {
+            reviewFabricRestrictions: {
+                arl: MatterStruct[];
+            };
+        };
+        events: {
+            accessControlEntryChanged: {
+                adminNodeId: NodeId | null;
+                adminPasscodeId: number | null;
+                changeType: MatterEnum;
+                latestValue: MatterStruct | null;
+            };
+            accessControlExtensionChanged: {
+                adminNodeId: NodeId | null;
+                adminPasscodeId: number | null;
+                changeType: MatterEnum;
+                latestValue: MatterStruct | null;
+            };
+            fabricRestrictionReviewUpdate: {
+                token: Int64;
+                instruction: string;
+                arlRequestFlowUrl: string;
+            };
+        };
+    };
+    'AccountLogin': {
+        features: {};
+        attributes: {};
+        commands: {
+            getSetupPIN: {
+                tempAccountIdentifier: string;
+            };
+            login: {
+                tempAccountIdentifier: string;
+                setupPin: string;
+                node: NodeId;
+            };
+            logout: {
+                node: NodeId;
+            };
+        };
+        events: {
+            loggedOut: {
+                node: NodeId;
+            };
+        };
+    };
+    'Actions': {
+        features: {};
+        attributes: {
+            actionList: MatterStruct[];
+            endpointLists: MatterStruct[];
+            setupUrl: string;
+        };
+        commands: {
+            disableAction: {
+                actionId: number;
+                invokeId: number;
+            };
+            disableActionWithDuration: {
+                actionId: number;
+                invokeId: number;
+                duration: number;
+            };
+            enableAction: {
+                actionId: number;
+                invokeId: number;
+            };
+            enableActionWithDuration: {
+                actionId: number;
+                invokeId: number;
+                duration: number;
+            };
+            instantAction: {
+                actionId: number;
+                invokeId: number;
+            };
+            instantActionWithTransition: {
+                actionId: number;
+                invokeId: number;
+                transitionTime: number;
+            };
+            pauseAction: {
+                actionId: number;
+                invokeId: number;
+            };
+            pauseActionWithDuration: {
+                actionId: number;
+                invokeId: number;
+                duration: number;
+            };
+            resumeAction: {
+                actionId: number;
+                invokeId: number;
+            };
+            startAction: {
+                actionId: number;
+                invokeId: number;
+            };
+            startActionWithDuration: {
+                actionId: number;
+                invokeId: number;
+                duration: number;
+            };
+            stopAction: {
+                actionId: number;
+                invokeId: number;
+            };
+        };
+        events: {
+            stateChanged: {
+                actionId: number;
+                invokeId: number;
+                newState: MatterEnum;
+            };
+            actionFailed: {
+                actionId: number;
+                invokeId: number;
+                newState: MatterEnum;
+                error: MatterEnum;
+            };
+        };
+    };
+    'ActivatedCarbonFilterMonitoring': {
+        features: {
+            CON: 'Condition';
+            REP: 'ReplacementProductList';
+            WRN: 'Warning';
+        };
+        attributes: {
+            changeIndication: MatterEnum;
+            condition: Percent;
+            degradationDirection: MatterEnum;
+            inPlaceIndicator: boolean;
+            lastChangedTime: EpochS | null;
+            replacementProductList: MatterStruct[];
+        };
+        commands: {
+            resetCondition: undefined;
+        };
+        events: {};
+    };
+    'AdministratorCommissioning': {
+        features: {
+            BC: 'Basic';
+        };
+        attributes: {
+            adminFabricIndex: FabricIndex | null;
+            adminVendorId: VendorId | null;
+            windowStatus: MatterEnum;
+        };
+        commands: {
+            openBasicCommissioningWindow: {
+                commissioningTimeout: number;
+            };
+            openCommissioningWindow: {
+                commissioningTimeout: number;
+                pakePasscodeVerifier: Bytes;
+                discriminator: number;
+                iterations: number;
+                salt: Bytes;
+            };
+            revokeCommissioning: undefined;
+        };
+        events: {};
+    };
+    'AirQuality': {
+        features: {
+            XPOOR: 'ExtremelyPoor';
+            FAIR: 'Fair';
+            MOD: 'Moderate';
+            VPOOR: 'VeryPoor';
+        };
+        attributes: {
+            airQuality: MatterEnum;
+        };
+        commands: {};
+        events: {};
+    };
+    'AlarmBaseCluster': {
+        features: {
+            RESET: 'Reset';
+        };
+        attributes: {
+            latch: MatterBitmap;
+            mask: MatterBitmap;
+            state: MatterBitmap;
+            supported: MatterBitmap;
+        };
+        commands: {
+            modifyEnabledAlarms: {
+                mask: MatterBitmap;
+            };
+            reset: {
+                alarms: MatterBitmap;
+            };
+        };
+        events: {
+            notify: {
+                active: MatterBitmap;
+                inactive: MatterBitmap;
+                state: MatterBitmap;
+                mask: MatterBitmap;
+            };
+        };
+    };
+    'ApplicationBasic': {
+        features: {};
+        attributes: {
+            allowedVendorList: VendorId[];
+            application: MatterStruct;
+            applicationName: string;
+            applicationVersion: string;
+            productId: number;
+            status: MatterEnum;
+            vendorId: VendorId;
+            vendorName: string;
+        };
+        commands: {};
+        events: {};
+    };
+    'ApplicationLauncher': {
+        features: {
+            AP: 'ApplicationPlatform';
+        };
+        attributes: {
+            catalogList: number[];
+            currentApp: MatterStruct | null;
+        };
+        commands: {
+            hideApp: {
+                application: MatterStruct;
+            };
+            launchApp: {
+                application: MatterStruct;
+                data: Bytes;
+            };
+            stopApp: {
+                application: MatterStruct;
+            };
+        };
+        events: {};
+    };
+    'AudioOutput': {
+        features: {
+            NU: 'NameUpdates';
+        };
+        attributes: {
+            currentOutput: number;
+            outputList: MatterStruct[];
+        };
+        commands: {
+            renameOutput: {
+                index: number;
+                name: string;
+            };
+            selectOutput: {
+                index: number;
+            };
+        };
+        events: {};
+    };
+    'BasicInformation': {
+        features: {};
+        attributes: {
+            capabilityMinima: MatterStruct;
+            configurationVersion: number;
+            dataModelRevision: number;
+            hardwareVersion: number;
+            hardwareVersionString: string;
+            localConfigDisabled: boolean;
+            location: string;
+            manufacturingDate: string;
+            maxPathsPerInvoke: number;
+            nodeLabel: string;
+            partNumber: string;
+            productAppearance: MatterStruct;
+            productId: number;
+            productLabel: string;
+            productName: string;
+            productUrl: string;
+            reachable: boolean;
+            serialNumber: string;
+            softwareVersion: number;
+            softwareVersionString: string;
+            specificationVersion: number;
+            uniqueId: string;
+            vendorId: VendorId;
+            vendorName: string;
+        };
+        commands: {};
+        events: {
+            startUp: {
+                softwareVersion: number;
+            };
+            shutDown: undefined;
+            leave: {
+                fabricIndex: FabricIndex;
+            };
+            reachableChanged: {
+                reachableNewValue: boolean;
+            };
+        };
+    };
+    'Binding': {
+        features: {};
+        attributes: {
+            binding: MatterStruct[];
+        };
+        commands: {};
+        events: {};
+    };
+    'BooleanState': {
+        features: {};
+        attributes: {
+            stateValue: boolean;
+        };
+        commands: {};
+        events: {
+            stateChange: {
+                stateValue: boolean;
+            };
+        };
+    };
+    'BooleanStateConfiguration': {
+        features: {
+            SPRS: 'AlarmSuppress';
+            AUD: 'Audible';
+            SENSLVL: 'SensitivityLevel';
+            VIS: 'Visual';
+        };
+        attributes: {
+            alarmsActive: MatterBitmap;
+            alarmsEnabled: MatterBitmap;
+            alarmsSupported: MatterBitmap;
+            alarmsSuppressed: MatterBitmap;
+            currentSensitivityLevel: number;
+            defaultSensitivityLevel: number;
+            sensorFault: MatterBitmap;
+            supportedSensitivityLevels: number;
+        };
+        commands: {
+            enableDisableAlarm: {
+                alarmsToEnableDisable: MatterBitmap;
+            };
+            suppressAlarm: {
+                alarmsToSuppress: MatterBitmap;
+            };
+        };
+        events: {
+            alarmsStateChanged: {
+                alarmsActive: MatterBitmap;
+                alarmsSuppressed: MatterBitmap;
+            };
+            sensorFault: {
+                sensorFault: MatterBitmap;
+            };
+        };
+    };
+    'BridgedDeviceBasicInformation': {
+        features: {
+            BIS: 'BridgedICDSupport';
+        };
+        attributes: {
+            capabilityMinima: MatterStruct;
+            configurationVersion: number;
+            dataModelRevision: number;
+            hardwareVersion: number;
+            hardwareVersionString: string;
+            localConfigDisabled: boolean;
+            location: string;
+            manufacturingDate: string;
+            maxPathsPerInvoke: number;
+            nodeLabel: string;
+            partNumber: string;
+            productAppearance: MatterStruct;
+            productId: number;
+            productLabel: string;
+            productName: string;
+            productUrl: string;
+            reachable: boolean;
+            serialNumber: string;
+            softwareVersion: number;
+            softwareVersionString: string;
+            specificationVersion: number;
+            uniqueId: string;
+            vendorId: VendorId;
+            vendorName: string;
+        };
+        commands: {
+            keepActive: {
+                stayActiveDuration: number;
+                timeoutMs: number;
+            };
+        };
+        events: {
+            startUp: {
+                softwareVersion: number;
+            };
+            shutDown: undefined;
+            leave: {
+                fabricIndex: FabricIndex;
+            };
+            reachableChanged: {
+                reachableNewValue: boolean;
+            };
+            activeChanged: {
+                promisedActiveDuration: number;
+            };
+        };
+    };
+    'CameraAVSettingsUserLevelManagement': {
+        features: {
+            DPTZ: 'DigitalPTZ';
+            MPAN: 'MechanicalPan';
+            MPRESETS: 'MechanicalPresets';
+            MTILT: 'MechanicalTilt';
+            MZOOM: 'MechanicalZoom';
+        };
+        attributes: {
+            dptzStreams: MatterStruct[];
+            maxPresets: number;
+            movementState: MatterEnum;
+            mptzPosition: MatterStruct;
+            mptzPresets: MatterStruct[];
+            panMax: number;
+            panMin: number;
+            tiltMax: number;
+            tiltMin: number;
+            zoomMax: number;
+        };
+        commands: {
+            dPTZRelativeMove: {
+                videoStreamId: VideoStreamId;
+                deltaX: number;
+                deltaY: number;
+                zoomDelta: number;
+            };
+            dPTZSetViewport: {
+                videoStreamId: VideoStreamId;
+                viewport: MatterStruct;
+            };
+            mPTZMoveToPreset: {
+                presetId: number;
+            };
+            mPTZRelativeMove: {
+                panDelta: number;
+                tiltDelta: number;
+                zoomDelta: number;
+            };
+            mPTZRemovePreset: {
+                presetId: number;
+            };
+            mPTZSavePreset: {
+                presetId: number;
+                name: string;
+            };
+            mPTZSetPosition: {
+                pan: number;
+                tilt: number;
+                zoom: number;
+            };
+        };
+        events: {};
+    };
+    'CameraAVStreamManagement': {
+        features: {
+            ADO: 'Audio';
+            HDR: 'HighDynamicRange';
+            ICTL: 'ImageControl';
+            STOR: 'LocalStorage';
+            NV: 'NightVision';
+            OSD: 'OnScreenDisplay';
+            PRIV: 'Privacy';
+            SNP: 'Snapshot';
+            SPKR: 'Speaker';
+            VDO: 'Video';
+            WMARK: 'Watermark';
+        };
+        attributes: {
+            allocatedAudioStreams: MatterStruct[];
+            allocatedSnapshotStreams: MatterStruct[];
+            allocatedVideoStreams: MatterStruct[];
+            currentFrameRate: number;
+            hardPrivacyModeOn: boolean;
+            hdrModeEnabled: boolean;
+            imageFlipHorizontal: boolean;
+            imageFlipVertical: boolean;
+            imageRotation: number;
+            localSnapshotRecordingEnabled: boolean;
+            localVideoRecordingEnabled: boolean;
+            maxConcurrentEncoders: number;
+            maxContentBufferSize: number;
+            maxEncodedPixelRate: number;
+            maxNetworkBandwidth: number;
+            microphoneAgcEnabled: boolean;
+            microphoneCapabilities: MatterStruct;
+            microphoneMaxLevel: number;
+            microphoneMinLevel: number;
+            microphoneMuted: boolean;
+            microphoneVolumeLevel: number;
+            minViewportResolution: MatterStruct;
+            nightVision: MatterEnum;
+            nightVisionIllum: MatterEnum;
+            nightVisionUsesInfrared: boolean;
+            rateDistortionTradeOffPoints: MatterStruct[];
+            snapshotCapabilities: MatterStruct[];
+            softLivestreamPrivacyModeEnabled: boolean;
+            softRecordingPrivacyModeEnabled: boolean;
+            speakerCapabilities: MatterStruct;
+            speakerMaxLevel: number;
+            speakerMinLevel: number;
+            speakerMuted: boolean;
+            speakerVolumeLevel: number;
+            statusLightBrightness: MatterEnum;
+            statusLightEnabled: boolean;
+            streamUsagePriorities: MatterEnum[];
+            supportedStreamUsages: MatterEnum[];
+            twoWayTalkSupport: MatterEnum;
+            videoSensorParams: MatterStruct;
+            viewport: MatterStruct;
+        };
+        commands: {
+            audioStreamAllocate: {
+                streamUsage: MatterEnum;
+                audioCodec: MatterEnum;
+                channelCount: number;
+                sampleRate: number;
+                bitRate: number;
+                bitDepth: number;
+            };
+            audioStreamDeallocate: {
+                audioStreamId: AudioStreamId;
+            };
+            captureSnapshot: {
+                snapshotStreamId: SnapshotStreamId | null;
+                requestedResolution: MatterStruct;
+            };
+            setStreamPriorities: {
+                streamPriorities: MatterEnum[];
+            };
+            snapshotStreamAllocate: {
+                imageCodec: MatterEnum;
+                maxFrameRate: number;
+                minResolution: MatterStruct;
+                maxResolution: MatterStruct;
+                quality: number;
+                watermarkEnabled: boolean;
+                osdEnabled: boolean;
+            };
+            snapshotStreamDeallocate: {
+                snapshotStreamId: SnapshotStreamId;
+            };
+            snapshotStreamModify: {
+                snapshotStreamId: SnapshotStreamId;
+                watermarkEnabled: boolean;
+                osdEnabled: boolean;
+            };
+            videoStreamAllocate: {
+                streamUsage: MatterEnum;
+                videoCodec: MatterEnum;
+                minFrameRate: number;
+                maxFrameRate: number;
+                minResolution: MatterStruct;
+                maxResolution: MatterStruct;
+                minBitRate: number;
+                maxBitRate: number;
+                keyFrameInterval: number;
+                watermarkEnabled: boolean;
+                osdEnabled: boolean;
+            };
+            videoStreamDeallocate: {
+                videoStreamId: VideoStreamId;
+            };
+            videoStreamModify: {
+                videoStreamId: VideoStreamId;
+                watermarkEnabled: boolean;
+                osdEnabled: boolean;
+            };
+        };
+        events: {};
+    };
+    'CarbonDioxideConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'CarbonMonoxideConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'Channel': {
+        features: {
+            CL: 'ChannelList';
+            EG: 'ElectronicGuide';
+            LI: 'LineupInfo';
+            RP: 'RecordProgram';
+        };
+        attributes: {
+            channelList: MatterStruct[];
+            currentChannel: MatterStruct | null;
+            lineup: MatterStruct | null;
+        };
+        commands: {
+            cancelRecordProgram: {
+                programIdentifier: string;
+                shouldRecordSeries: boolean;
+                externalIdList: MatterStruct[];
+                data: Bytes;
+            };
+            changeChannel: {
+                match: string;
+            };
+            changeChannelByNumber: {
+                majorNumber: number;
+                minorNumber: number;
+            };
+            getProgramGuide: {
+                startTime: EpochS;
+                endTime: EpochS;
+                channelList: MatterStruct[];
+                pageToken: MatterStruct | null;
+                recordingFlag: MatterBitmap | null;
+                externalIdList: MatterStruct[];
+                data: Bytes;
+            };
+            recordProgram: {
+                programIdentifier: string;
+                shouldRecordSeries: boolean;
+                externalIdList: MatterStruct[];
+                data: Bytes;
+            };
+            skipChannel: {
+                count: number;
+            };
+        };
+        events: {};
+    };
+    'Chime': {
+        features: {};
+        attributes: {
+            enabled: boolean;
+            installedChimeSounds: MatterStruct[];
+            selectedChime: number;
+        };
+        commands: {
+            playChimeSound: {
+                chimeId: number;
+            };
+        };
+        events: {
+            chimeStartedPlaying: {
+                chimeId: number;
+            };
+        };
+    };
+    'ClosureControl': {
+        features: {
+            CL: 'Calibration';
+            IS: 'Instantaneous';
+            MO: 'ManuallyOperable';
+            LT: 'MotionLatching';
+            PD: 'Pedestrian';
+            PS: 'Positioning';
+            PT: 'Protection';
+            SP: 'Speed';
+            VT: 'Ventilation';
+        };
+        attributes: {
+            countdownTime: ElapsedS | null;
+            currentErrorList: MatterEnum[];
+            latchControlModes: MatterBitmap;
+            mainState: MatterEnum;
+            overallCurrentState: MatterStruct | null;
+            overallTargetState: MatterStruct | null;
+        };
+        commands: {
+            calibrate: undefined;
+            moveTo: {
+                position: MatterEnum;
+                latch: boolean;
+                speed: MatterEnum;
+            };
+            stop: undefined;
+        };
+        events: {
+            operationalError: {
+                errorState: MatterEnum[];
+            };
+            movementCompleted: undefined;
+            engageStateChanged: {
+                engageValue: boolean;
+            };
+            secureStateChanged: {
+                secureValue: boolean;
+            };
+        };
+    };
+    'ClosureDimension': {
+        features: {
+            LM: 'Limitation';
+            MD: 'Modulation';
+            LT: 'MotionLatching';
+            PS: 'Positioning';
+            RO: 'Rotation';
+            SP: 'Speed';
+            TR: 'Translation';
+            UT: 'Unit';
+        };
+        attributes: {
+            currentState: MatterStruct | null;
+            latchControlModes: MatterBitmap;
+            limitRange: MatterStruct;
+            modulationType: MatterEnum;
+            overflow: MatterEnum;
+            resolution: Percent100Ths;
+            rotationAxis: MatterEnum;
+            stepValue: Percent100Ths;
+            targetState: MatterStruct | null;
+            translationDirection: MatterEnum;
+            unit: MatterEnum;
+            unitRange: MatterStruct | null;
+        };
+        commands: {
+            setTarget: {
+                position: Percent100Ths;
+                latch: boolean;
+                speed: MatterEnum;
+            };
+            step: {
+                direction: MatterEnum;
+                numberOfSteps: number;
+                speed: MatterEnum;
+            };
+        };
+        events: {};
+    };
+    'ColorControl': {
+        features: {
+            CL: 'ColorLoop';
+            CT: 'ColorTemperature';
+            EHUE: 'EnhancedHue';
+            HS: 'HueSaturation';
+            XY: 'XY';
+        };
+        attributes: {
+            colorCapabilities: MatterBitmap;
+            colorLoopActive: number;
+            colorLoopDirection: MatterEnum;
+            colorLoopStartEnhancedHue: number;
+            colorLoopStoredEnhancedHue: number;
+            colorLoopTime: number;
+            colorMode: MatterEnum;
+            colorPointBIntensity: number | null;
+            colorPointBx: number;
+            colorPointBy: number;
+            colorPointGIntensity: number | null;
+            colorPointGx: number;
+            colorPointGy: number;
+            colorPointRIntensity: number | null;
+            colorPointRx: number;
+            colorPointRy: number;
+            colorTemperatureMireds: number;
+            colorTempPhysicalMaxMireds: number;
+            colorTempPhysicalMinMireds: number;
+            compensationText: string;
+            coupleColorTempToLevelMinMireds: number;
+            currentHue: number;
+            currentSaturation: number;
+            currentX: number;
+            currentY: number;
+            driftCompensation: MatterEnum;
+            enhancedColorMode: MatterEnum;
+            enhancedCurrentHue: number;
+            numberOfPrimaries: number | null;
+            options: MatterBitmap;
+            primary1Intensity: number | null;
+            primary1X: number;
+            primary1Y: number;
+            primary2Intensity: number | null;
+            primary2X: number;
+            primary2Y: number;
+            primary3Intensity: number | null;
+            primary3X: number;
+            primary3Y: number;
+            primary4Intensity: number | null;
+            primary4X: number;
+            primary4Y: number;
+            primary5Intensity: number | null;
+            primary5X: number;
+            primary5Y: number;
+            primary6Intensity: number | null;
+            primary6X: number;
+            primary6Y: number;
+            remainingTime: number;
+            startUpColorTemperatureMireds: number | null;
+            whitePointX: number;
+            whitePointY: number;
+        };
+        commands: {
+            colorLoopSet: {
+                updateFlags: MatterBitmap;
+                action: MatterEnum;
+                direction: MatterEnum;
+                time: number;
+                startHue: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            enhancedMoveHue: {
+                moveMode: MatterEnum;
+                rate: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            enhancedMoveToHue: {
+                enhancedHue: number;
+                direction: MatterEnum;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            enhancedMoveToHueAndSaturation: {
+                enhancedHue: number;
+                saturation: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            enhancedStepHue: {
+                stepMode: MatterEnum;
+                stepSize: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveColor: {
+                rateX: number;
+                rateY: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveColorTemperature: {
+                moveMode: MatterEnum;
+                rate: number;
+                colorTemperatureMinimumMireds: number;
+                colorTemperatureMaximumMireds: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveHue: {
+                moveMode: MatterEnum;
+                rate: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveSaturation: {
+                moveMode: MatterEnum;
+                rate: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToColor: {
+                colorX: number;
+                colorY: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToColorTemperature: {
+                colorTemperatureMireds: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToHue: {
+                hue: number;
+                direction: MatterEnum;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToHueAndSaturation: {
+                hue: number;
+                saturation: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToSaturation: {
+                saturation: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stepColor: {
+                stepX: number;
+                stepY: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stepColorTemperature: {
+                stepMode: MatterEnum;
+                stepSize: number;
+                transitionTime: number;
+                colorTemperatureMinimumMireds: number;
+                colorTemperatureMaximumMireds: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stepHue: {
+                stepMode: MatterEnum;
+                stepSize: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stepSaturation: {
+                stepMode: MatterEnum;
+                stepSize: number;
+                transitionTime: number;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stopMoveStep: {
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+        };
+        events: {};
+    };
+    'CommissionerControl': {
+        features: {};
+        attributes: {
+            supportedDeviceCategories: MatterBitmap;
+        };
+        commands: {
+            commissionNode: {
+                requestId: Int64;
+                responseTimeoutSeconds: number;
+            };
+            requestCommissioningApproval: {
+                requestId: Int64;
+                vendorId: VendorId;
+                productId: number;
+                label: string;
+            };
+        };
+        events: {
+            commissioningRequestResult: {
+                requestId: Int64;
+                clientNodeId: NodeId;
+                statusCode: Status;
+            };
+        };
+    };
+    'CommodityMetering': {
+        features: {};
+        attributes: {
+            maximumMeteredQuantities: number | null;
+            meteredQuantity: MatterStruct[] | null;
+            meteredQuantityTimestamp: EpochS | null;
+            tariffUnit: MatterEnum | null;
+        };
+        commands: {};
+        events: {};
+    };
+    'CommodityPrice': {
+        features: {
+            FORE: 'Forecasting';
+        };
+        attributes: {
+            currency: MatterStruct | null;
+            currentPrice: MatterStruct | null;
+            priceForecast: MatterStruct[];
+            tariffUnit: MatterEnum;
+        };
+        commands: {
+            getDetailedForecastRequest: {
+                details: MatterBitmap;
+            };
+            getDetailedPriceRequest: {
+                details: MatterBitmap;
+            };
+        };
+        events: {
+            priceChange: {
+                currentPrice: MatterStruct | null;
+            };
+        };
+    };
+    'CommodityTariff': {
+        features: {
+            AUXLD: 'AuxiliaryLoad';
+            FCRED: 'FriendlyCredit';
+            PEAKP: 'PeakPeriod';
+            PWRTHLD: 'PowerThreshold';
+            PRICE: 'Pricing';
+            RNDM: 'Randomization';
+        };
+        attributes: {
+            calendarPeriods: MatterStruct[] | null;
+            currentDay: MatterStruct | null;
+            currentDayEntry: MatterStruct | null;
+            currentDayEntryDate: EpochS | null;
+            currentTariffComponents: MatterStruct[] | null;
+            dayEntries: MatterStruct[] | null;
+            dayPatterns: MatterStruct[] | null;
+            defaultRandomizationOffset: number | null;
+            defaultRandomizationType: MatterEnum | null;
+            individualDays: MatterStruct[] | null;
+            nextDay: MatterStruct | null;
+            nextDayEntry: MatterStruct | null;
+            nextDayEntryDate: EpochS | null;
+            nextTariffComponents: MatterStruct[] | null;
+            startDate: EpochS | null;
+            tariffComponents: MatterStruct[] | null;
+            tariffInfo: MatterStruct | null;
+            tariffPeriods: MatterStruct[] | null;
+            tariffUnit: MatterEnum | null;
+        };
+        commands: {
+            getDayEntry: {
+                dayEntryId: number;
+            };
+            getTariffComponent: {
+                tariffComponentId: number;
+            };
+        };
+        events: {};
+    };
+    'ConcentrationMeasurementClusters': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'ContentAppObserver': {
+        features: {};
+        attributes: {};
+        commands: {
+            contentAppMessage: {
+                data: string;
+                encodingHint: string;
+            };
+        };
+        events: {};
+    };
+    'ContentControl': {
+        features: {
+            BA: 'BlockApplications';
+            BC: 'BlockChannels';
+            BTW: 'BlockContentTimeWindow';
+            BU: 'BlockUnrated';
+            OCR: 'OnDemandContentRating';
+            PM: 'PINManagement';
+            SCR: 'ScheduledContentRating';
+            ST: 'ScreenTime';
+        };
+        attributes: {
+            blockApplicationList: MatterStruct[];
+            blockChannelList: MatterStruct[];
+            blockContentTimeWindow: MatterStruct[];
+            blockUnrated: boolean;
+            enabled: boolean;
+            onDemandRatings: MatterStruct[];
+            onDemandRatingThreshold: string;
+            remainingScreenTime: ElapsedS;
+            scheduledContentRatings: MatterStruct[];
+            scheduledContentRatingThreshold: string;
+            screenDailyTime: ElapsedS;
+        };
+        commands: {
+            addBlockApplications: {
+                applications: MatterStruct[];
+            };
+            addBlockChannels: {
+                channels: MatterStruct[];
+            };
+            addBonusTime: {
+                pinCode: string;
+                bonusTime: ElapsedS;
+            };
+            blockUnratedContent: undefined;
+            disable: undefined;
+            enable: undefined;
+            removeBlockApplications: {
+                applications: MatterStruct[];
+            };
+            removeBlockChannels: {
+                channelIndexes: number[];
+            };
+            removeBlockContentTimeWindow: {
+                timeWindowIndexes: number[];
+            };
+            resetPIN: undefined;
+            setBlockContentTimeWindow: {
+                timeWindow: MatterStruct;
+            };
+            setOnDemandRatingThreshold: {
+                rating: string;
+            };
+            setScheduledContentRatingThreshold: {
+                rating: string;
+            };
+            setScreenDailyTime: {
+                screenTime: ElapsedS;
+            };
+            unblockUnratedContent: undefined;
+            updatePIN: {
+                oldPin: string;
+                newPin: string;
+            };
+        };
+        events: {
+            remainingScreenTimeExpired: undefined;
+            enteringBlockContentTimeWindow: undefined;
+        };
+    };
+    'ContentLauncher': {
+        features: {
+            AS: 'AdvancedSeek';
+            AT: 'AudioTracks';
+            CS: 'ContentSearch';
+            TT: 'TextTracks';
+            UP: 'URLPlayback';
+        };
+        attributes: {
+            acceptHeader: string[];
+            supportedStreamingProtocols: MatterBitmap;
+        };
+        commands: {
+            launchContent: {
+                search: MatterStruct;
+                autoPlay: boolean;
+                data: string;
+                playbackPreferences: MatterStruct;
+                useCurrentContext: boolean;
+            };
+            launchURL: {
+                contentUrl: string;
+                displayString: string;
+                brandingInformation: MatterStruct;
+                playbackPreferences: MatterStruct;
+            };
+        };
+        events: {};
+    };
+    'Descriptor': {
+        features: {
+            TAGLIST: 'TagList';
+        };
+        attributes: {
+            clientList: ClusterId[];
+            deviceTypeList: MatterStruct[];
+            endpointUniqueId: string;
+            partsList: EndpointNumber[];
+            serverList: ClusterId[];
+            tagList: Semtag[];
+        };
+        commands: {};
+        events: {};
+    };
+    'DeviceEnergyManagement': {
+        features: {
+            CON: 'ConstraintBasedAdjustment';
+            FA: 'ForecastAdjustment';
+            PAU: 'Pausable';
+            PA: 'PowerAdjustment';
+            PFR: 'PowerForecastReporting';
+            STA: 'StartTimeAdjustment';
+            SFR: 'StateForecastReporting';
+        };
+        attributes: {
+            absMaxPower: Int64;
+            absMinPower: Int64;
+            esaCanGenerate: boolean;
+            esaState: MatterEnum;
+            esaType: MatterEnum;
+            forecast: MatterStruct | null;
+            optOutState: MatterEnum;
+            powerAdjustmentCapability: MatterStruct | null;
+        };
+        commands: {
+            cancelPowerAdjustRequest: undefined;
+            cancelRequest: undefined;
+            modifyForecastRequest: {
+                forecastId: number;
+                slotAdjustments: MatterStruct[];
+                cause: MatterEnum;
+            };
+            pauseRequest: {
+                duration: ElapsedS;
+                cause: MatterEnum;
+            };
+            powerAdjustRequest: {
+                power: Int64;
+                duration: ElapsedS;
+                cause: MatterEnum;
+            };
+            requestConstraintBasedForecast: {
+                constraints: MatterStruct[];
+                cause: MatterEnum;
+            };
+            resumeRequest: undefined;
+            startTimeAdjustRequest: {
+                requestedStartTime: EpochS;
+                cause: MatterEnum;
+            };
+        };
+        events: {
+            powerAdjustStart: undefined;
+            powerAdjustEnd: {
+                cause: MatterEnum;
+                duration: ElapsedS;
+                energyUse: Int64;
+            };
+            paused: undefined;
+            resumed: {
+                cause: MatterEnum;
+            };
+        };
+    };
+    'DeviceEnergyManagementMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'DiagnosticLogs': {
+        features: {};
+        attributes: {};
+        commands: {
+            retrieveLogsRequest: {
+                intent: MatterEnum;
+                requestedProtocol: MatterEnum;
+                transferFileDesignator: string;
+            };
+        };
+        events: {};
+    };
+    'DishwasherAlarm': {
+        features: {
+            RESET: 'Reset';
+        };
+        attributes: {
+            latch: MatterBitmap;
+            mask: MatterBitmap;
+            state: MatterBitmap;
+            supported: MatterBitmap;
+        };
+        commands: {
+            modifyEnabledAlarms: {
+                mask: MatterBitmap;
+            };
+            reset: {
+                alarms: MatterBitmap;
+            };
+        };
+        events: {
+            notify: {
+                active: MatterBitmap;
+                inactive: MatterBitmap;
+                state: MatterBitmap;
+                mask: MatterBitmap;
+            };
+        };
+    };
+    'DishwasherMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'DoorLock': {
+        features: {
+            ALBU: 'AliroBLEUWB';
+            ALIRO: 'AliroProvisioning';
+            COTA: 'CredentialOverTheAirAccess';
+            DPS: 'DoorPositionSensor';
+            FACE: 'FaceCredentials';
+            FGP: 'FingerCredentials';
+            HDSCH: 'HolidaySchedules';
+            PIN: 'PINCredential';
+            RID: 'RFIDCredential';
+            UBOLT: 'Unbolting';
+            USR: 'User';
+            WDSCH: 'WeekDayAccessSchedules';
+            YDSCH: 'YearDayAccessSchedules';
+        };
+        attributes: {
+            actuatorEnabled: boolean;
+            aliroBleAdvertisingVersion: number;
+            aliroExpeditedTransactionSupportedProtocolVersions: Bytes[];
+            aliroGroupResolvingKey: Bytes | null;
+            aliroReaderGroupIdentifier: Bytes | null;
+            aliroReaderGroupSubIdentifier: Bytes;
+            aliroReaderVerificationKey: Bytes | null;
+            aliroSupportedBleuwbProtocolVersions: Bytes[];
+            autoRelockTime: number;
+            credentialRulesSupport: MatterBitmap;
+            defaultConfigurationRegister: MatterBitmap;
+            doorClosedEvents: number;
+            doorOpenEvents: number;
+            doorState: MatterEnum | null;
+            enableInsideStatusLed: boolean;
+            enableLocalProgramming: boolean;
+            enableOneTouchLocking: boolean;
+            enablePrivacyModeButton: boolean;
+            expiringUserTimeout: number;
+            language: string;
+            ledSettings: MatterEnum;
+            localProgrammingFeatures: MatterBitmap;
+            lockState: MatterEnum | null;
+            lockType: MatterEnum;
+            maxPinCodeLength: number;
+            maxRfidCodeLength: number;
+            minPinCodeLength: number;
+            minRfidCodeLength: number;
+            numberOfAliroCredentialIssuerKeysSupported: number;
+            numberOfAliroEndpointKeysSupported: number;
+            numberOfCredentialsSupportedPerUser: number;
+            numberOfHolidaySchedulesSupported: number;
+            numberOfPinUsersSupported: number;
+            numberOfRfidUsersSupported: number;
+            numberOfTotalUsersSupported: number;
+            numberOfWeekDaySchedulesSupportedPerUser: number;
+            numberOfYearDaySchedulesSupportedPerUser: number;
+            openPeriod: number;
+            operatingMode: MatterEnum;
+            requirePiNforRemoteOperation: boolean;
+            securityLevel: number;
+            sendPinOverTheAir: boolean;
+            soundVolume: MatterEnum;
+            supportedOperatingModes: MatterBitmap;
+            userCodeTemporaryDisableTime: number;
+            wrongCodeEntryLimit: number;
+        };
+        commands: {
+            clearAliroReaderConfig: undefined;
+            clearCredential: {
+                credential: MatterStruct | null;
+            };
+            clearHolidaySchedule: {
+                holidayIndex: number;
+            };
+            clearUser: {
+                userIndex: number;
+            };
+            clearWeekDaySchedule: {
+                weekDayIndex: number;
+                userIndex: number;
+            };
+            clearYearDaySchedule: {
+                yearDayIndex: number;
+                userIndex: number;
+            };
+            getCredentialStatus: {
+                credential: MatterStruct;
+            };
+            getHolidaySchedule: {
+                holidayIndex: number;
+            };
+            getUser: {
+                userIndex: number;
+            };
+            getWeekDaySchedule: {
+                weekDayIndex: number;
+                userIndex: number;
+            };
+            getYearDaySchedule: {
+                yearDayIndex: number;
+                userIndex: number;
+            };
+            lockDoor: {
+                pinCode: Bytes;
+            };
+            setAliroReaderConfig: {
+                signingKey: Bytes;
+                verificationKey: Bytes;
+                groupIdentifier: Bytes;
+                groupResolvingKey: Bytes;
+            };
+            setCredential: {
+                operationType: MatterEnum;
+                credential: MatterStruct;
+                credentialData: Bytes;
+                userIndex: number | null;
+                userStatus: MatterEnum | null;
+                userType: MatterEnum | null;
+            };
+            setHolidaySchedule: {
+                holidayIndex: number;
+                localStartTime: EpochS;
+                localEndTime: EpochS;
+                operatingMode: MatterEnum;
+            };
+            setUser: {
+                operationType: MatterEnum;
+                userIndex: number;
+                userName: string | null;
+                userUniqueId: number | null;
+                userStatus: MatterEnum | null;
+                userType: MatterEnum | null;
+                credentialRule: MatterEnum | null;
+            };
+            setWeekDaySchedule: {
+                weekDayIndex: number;
+                userIndex: number;
+                daysMask: MatterBitmap;
+                startHour: number;
+                startMinute: number;
+                endHour: number;
+                endMinute: number;
+            };
+            setYearDaySchedule: {
+                yearDayIndex: number;
+                userIndex: number;
+                localStartTime: EpochS;
+                localEndTime: EpochS;
+            };
+            toggle: undefined;
+            unboltDoor: {
+                pinCode: Bytes;
+            };
+            unlockDoor: {
+                pinCode: Bytes;
+            };
+            unlockWithTimeout: {
+                timeout: number;
+                pinCode: Bytes;
+            };
+        };
+        events: {
+            doorLockAlarm: {
+                alarmCode: MatterEnum;
+            };
+            doorStateChange: {
+                doorState: MatterEnum;
+            };
+            lockOperation: {
+                lockOperationType: MatterEnum;
+                operationSource: MatterEnum;
+                userIndex: number | null;
+                fabricIndex: FabricIndex | null;
+                sourceNode: NodeId | null;
+                credentials: MatterStruct[] | null;
+            };
+            lockOperationError: {
+                lockOperationType: MatterEnum;
+                operationSource: MatterEnum;
+                operationError: MatterEnum;
+                userIndex: number | null;
+                fabricIndex: FabricIndex | null;
+                sourceNode: NodeId | null;
+                credentials: MatterStruct[] | null;
+            };
+            lockUserChange: {
+                lockDataType: MatterEnum;
+                dataOperationType: MatterEnum;
+                operationSource: MatterEnum;
+                userIndex: number | null;
+                fabricIndex: FabricIndex | null;
+                sourceNode: NodeId | null;
+                dataIndex: number | null;
+            };
+        };
+    };
+    'EcosystemInformation': {
+        features: {};
+        attributes: {
+            deviceDirectory: MatterStruct[];
+            locationDirectory: MatterStruct[];
+        };
+        commands: {};
+        events: {};
+    };
+    'ElectricalEnergyMeasurement': {
+        features: {
+            APPE: 'ApparentEnergy';
+            CUME: 'CumulativeEnergy';
+            EXPE: 'ExportedEnergy';
+            IMPE: 'ImportedEnergy';
+            PERE: 'PeriodicEnergy';
+            REAE: 'ReactiveEnergy';
+        };
+        attributes: {
+            accuracy: MatterStruct;
+            cumulativeEnergyExported: MatterStruct | null;
+            cumulativeEnergyImported: MatterStruct | null;
+            cumulativeEnergyReset: MatterStruct | null;
+            periodicEnergyExported: MatterStruct | null;
+            periodicEnergyImported: MatterStruct | null;
+        };
+        commands: {};
+        events: {
+            cumulativeEnergyMeasured: {
+                energyImported: MatterStruct;
+                energyExported: MatterStruct;
+            };
+            periodicEnergyMeasured: {
+                energyImported: MatterStruct;
+                energyExported: MatterStruct;
+            };
+        };
+    };
+    'ElectricalGridConditions': {
+        features: {
+            FORE: 'Forecasting';
+        };
+        attributes: {
+            currentConditions: MatterStruct | null;
+            forecastConditions: MatterStruct[];
+            localGenerationAvailable: boolean | null;
+        };
+        commands: {};
+        events: {
+            currentConditionsChanged: {
+                currentConditions: MatterStruct | null;
+            };
+        };
+    };
+    'ElectricalPowerMeasurement': {
+        features: {
+            ALTC: 'AlternatingCurrent';
+            DIRC: 'DirectCurrent';
+            HARM: 'Harmonics';
+            POLY: 'PolyphasePower';
+            PWRQ: 'PowerQuality';
+        };
+        attributes: {
+            accuracy: MatterStruct[];
+            activeCurrent: Int64 | null;
+            activePower: Int64 | null;
+            apparentCurrent: Int64 | null;
+            apparentPower: Int64 | null;
+            frequency: Int64 | null;
+            harmonicCurrents: MatterStruct[] | null;
+            harmonicPhases: MatterStruct[] | null;
+            neutralCurrent: Int64 | null;
+            numberOfMeasurementTypes: number;
+            powerFactor: Int64 | null;
+            powerMode: MatterEnum;
+            ranges: MatterStruct[];
+            reactiveCurrent: Int64 | null;
+            reactivePower: Int64 | null;
+            rmsCurrent: Int64 | null;
+            rmsPower: Int64 | null;
+            rmsVoltage: Int64 | null;
+            voltage: Int64 | null;
+        };
+        commands: {};
+        events: {
+            measurementPeriodRanges: {
+                ranges: MatterStruct[];
+            };
+        };
+    };
+    'EnergyEVSE': {
+        features: {
+            PREF: 'ChargingPreferences';
+            PNC: 'PlugAndCharge';
+            RFID: 'RFID';
+            SOC: 'SoCReporting';
+            V2X: 'V2X';
+        };
+        attributes: {
+            approximateEvEfficiency: number | null;
+            batteryCapacity: Int64 | null;
+            chargingEnabledUntil: EpochS | null;
+            circuitCapacity: Int64;
+            dischargingEnabledUntil: EpochS | null;
+            faultState: MatterEnum;
+            maximumChargeCurrent: Int64;
+            maximumDischargeCurrent: Int64;
+            minimumChargeCurrent: Int64;
+            nextChargeRequiredEnergy: Int64 | null;
+            nextChargeStartTime: EpochS | null;
+            nextChargeTargetSoC: Percent | null;
+            nextChargeTargetTime: EpochS | null;
+            randomizationDelayWindow: ElapsedS;
+            sessionDuration: ElapsedS | null;
+            sessionEnergyCharged: Int64 | null;
+            sessionEnergyDischarged: Int64 | null;
+            sessionId: number | null;
+            state: MatterEnum | null;
+            stateOfCharge: Percent | null;
+            supplyState: MatterEnum;
+            userMaximumChargeCurrent: Int64;
+            vehicleId: string | null;
+        };
+        commands: {
+            clearTargets: undefined;
+            disable: undefined;
+            enableCharging: {
+                chargingEnabledUntil: EpochS | null;
+                minimumChargeCurrent: Int64;
+                maximumChargeCurrent: Int64;
+            };
+            enableDischarging: {
+                dischargingEnabledUntil: EpochS | null;
+                maximumDischargeCurrent: Int64;
+            };
+            getTargets: undefined;
+            setTargets: {
+                chargingTargetSchedules: MatterStruct[];
+            };
+            startDiagnostics: undefined;
+        };
+        events: {
+            evConnected: {
+                sessionId: number;
+            };
+            evNotDetected: {
+                sessionId: number;
+                state: MatterEnum;
+                sessionDuration: ElapsedS;
+                sessionEnergyCharged: Int64;
+                sessionEnergyDischarged: Int64;
+            };
+            energyTransferStarted: {
+                sessionId: number;
+                state: MatterEnum;
+                maximumCurrent: Int64;
+                maximumDischargeCurrent: Int64;
+            };
+            energyTransferStopped: {
+                sessionId: number;
+                state: MatterEnum;
+                reason: MatterEnum;
+                energyTransferred: Int64;
+                energyDischarged: Int64;
+            };
+            fault: {
+                sessionId: number | null;
+                state: MatterEnum;
+                faultStatePreviousState: MatterEnum;
+                faultStateCurrentState: MatterEnum;
+            };
+            rfid: {
+                uid: Bytes;
+            };
+        };
+    };
+    'EnergyEVSEMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'EnergyPreference': {
+        features: {
+            BALA: 'EnergyBalance';
+            LPMS: 'LowPowerModeSensitivity';
+        };
+        attributes: {
+            currentEnergyBalance: number;
+            currentLowPowerModeSensitivity: number;
+            energyBalances: MatterStruct[];
+            energyPriorities: MatterEnum[];
+            lowPowerModeSensitivities: MatterStruct[];
+        };
+        commands: {};
+        events: {};
+    };
+    'EthernetNetworkDiagnostics': {
+        features: {
+            ERRCNT: 'ErrorCounts';
+            PKTCNT: 'PacketCounts';
+        };
+        attributes: {
+            carrierDetect: boolean | null;
+            collisionCount: Int64;
+            fullDuplex: boolean | null;
+            overrunCount: Int64;
+            packetRxCount: Int64;
+            packetTxCount: Int64;
+            phyRate: MatterEnum | null;
+            timeSinceReset: Int64;
+            txErrCount: Int64;
+        };
+        commands: {
+            resetCounts: undefined;
+        };
+        events: {};
+    };
+    'FanControl': {
+        features: {
+            DIR: 'AirflowDirection';
+            AUT: 'Auto';
+            SPD: 'MultiSpeed';
+            RCK: 'Rocking';
+            STEP: 'Step';
+            WND: 'Wind';
+        };
+        attributes: {
+            airflowDirection: MatterEnum;
+            fanMode: MatterEnum;
+            fanModeSequence: MatterEnum;
+            percentCurrent: Percent;
+            percentSetting: Percent | null;
+            rockSetting: MatterBitmap;
+            rockSupport: MatterBitmap;
+            speedCurrent: number;
+            speedMax: number;
+            speedSetting: number | null;
+            windSetting: MatterBitmap;
+            windSupport: MatterBitmap;
+        };
+        commands: {
+            step: {
+                direction: MatterEnum;
+                wrap: boolean;
+                lowestOff: boolean;
+            };
+        };
+        events: {};
+    };
+    'FixedLabel': {
+        features: {};
+        attributes: {
+            labelList: LabelStruct[];
+        };
+        commands: {};
+        events: {};
+    };
+    'FlowMeasurement': {
+        features: {};
+        attributes: {
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            minMeasuredValue: number | null;
+            tolerance: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'FormaldehydeConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'GeneralCommissioning': {
+        features: {
+            NR: 'NetworkRecovery';
+            TC: 'TermsAndConditions';
+        };
+        attributes: {
+            basicCommissioningInfo: MatterStruct;
+            breadcrumb: Int64;
+            isCommissioningWithoutPower: boolean;
+            locationCapability: MatterEnum;
+            networkRecoveryReason: MatterEnum | null;
+            recoveryIdentifier: Bytes;
+            regulatoryConfig: MatterEnum;
+            supportsConcurrentConnection: boolean;
+            tcAcceptedVersion: number;
+            tcAcknowledgements: MatterBitmap;
+            tcAcknowledgementsRequired: boolean;
+            tcMinRequiredVersion: number;
+            tcUpdateDeadline: number | null;
+        };
+        commands: {
+            armFailSafe: {
+                expiryLengthSeconds: number;
+                breadcrumb: Int64;
+            };
+            commissioningComplete: undefined;
+            setRegulatoryConfig: {
+                newRegulatoryConfig: MatterEnum;
+                countryCode: string;
+                breadcrumb: Int64;
+            };
+            setTCAcknowledgements: {
+                tcVersion: number;
+                tcUserResponse: MatterBitmap;
+            };
+        };
+        events: {};
+    };
+    'GeneralDiagnostics': {
+        features: {
+            DMTEST: 'DataModelTest';
+        };
+        attributes: {
+            activeHardwareFaults: MatterEnum[];
+            activeNetworkFaults: MatterEnum[];
+            activeRadioFaults: MatterEnum[];
+            bootReason: MatterEnum;
+            doNotUse: never;
+            networkInterfaces: MatterStruct[];
+            rebootCount: number;
+            testEventTriggersEnabled: boolean;
+            totalOperationalHours: number;
+            upTime: Int64;
+        };
+        commands: {
+            payloadTestRequest: {
+                enableKey: Bytes;
+                value: number;
+                count: number;
+            };
+            testEventTrigger: {
+                enableKey: Bytes;
+                eventTrigger: Int64;
+            };
+            timeSnapshot: undefined;
+        };
+        events: {
+            hardwareFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+            radioFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+            networkFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+            bootReason: {
+                bootReason: MatterEnum;
+            };
+        };
+    };
+    'GroupKeyManagement': {
+        features: {
+            CS: 'CacheAndSync';
+        };
+        attributes: {
+            groupKeyMap: MatterStruct[];
+            groupTable: MatterStruct[];
+            maxGroupKeysPerFabric: number;
+            maxGroupsPerFabric: number;
+        };
+        commands: {
+            keySetRead: {
+                groupKeySetId: number;
+            };
+            keySetReadAllIndices: undefined;
+            keySetRemove: {
+                groupKeySetId: number;
+            };
+            keySetWrite: {
+                groupKeySet: MatterStruct;
+            };
+        };
+        events: {};
+    };
+    'Groups': {
+        features: {
+            GN: 'GroupNames';
+        };
+        attributes: {
+            nameSupport: MatterBitmap;
+        };
+        commands: {
+            addGroup: {
+                groupId: GroupId;
+                groupName: string;
+            };
+            addGroupIfIdentifying: {
+                groupId: GroupId;
+                groupName: string;
+            };
+            getGroupMembership: {
+                groupList: GroupId[];
+            };
+            removeAllGroups: undefined;
+            removeGroup: {
+                groupId: GroupId;
+            };
+            viewGroup: {
+                groupId: GroupId;
+            };
+        };
+        events: {};
+    };
+    'HEPAFilterMonitoring': {
+        features: {
+            CON: 'Condition';
+            REP: 'ReplacementProductList';
+            WRN: 'Warning';
+        };
+        attributes: {
+            changeIndication: MatterEnum;
+            condition: Percent;
+            degradationDirection: MatterEnum;
+            inPlaceIndicator: boolean;
+            lastChangedTime: EpochS | null;
+            replacementProductList: MatterStruct[];
+        };
+        commands: {
+            resetCondition: undefined;
+        };
+        events: {};
+    };
+    'ICDManagement': {
+        features: {
+            CIP: 'CheckInProtocolSupport';
+            DSLS: 'DynamicSitLitSupport';
+            LITS: 'LongIdleTimeSupport';
+            UAT: 'UserActiveModeTrigger';
+        };
+        attributes: {
+            activeModeDuration: number;
+            activeModeThreshold: number;
+            clientsSupportedPerFabric: number;
+            icdCounter: number;
+            idleModeDuration: number;
+            maximumCheckInBackoff: number;
+            operatingMode: MatterEnum;
+            registeredClients: MatterStruct[];
+            userActiveModeTriggerHint: MatterBitmap;
+            userActiveModeTriggerInstruction: string;
+        };
+        commands: {
+            registerClient: {
+                checkInNodeId: NodeId;
+                monitoredSubject: SubjectId;
+                key: Bytes;
+                verificationKey: Bytes;
+                clientType: MatterEnum;
+            };
+            stayActiveRequest: {
+                stayActiveDuration: number;
+            };
+            unregisterClient: {
+                checkInNodeId: NodeId;
+                verificationKey: Bytes;
+            };
+        };
+        events: {};
+    };
+    'Identify': {
+        features: {};
+        attributes: {
+            identifyTime: number;
+            identifyType: MatterEnum;
+        };
+        commands: {
+            identify: {
+                identifyTime: number;
+            };
+            triggerEffect: {
+                effectIdentifier: MatterEnum;
+                effectVariant: MatterEnum;
+            };
+        };
+        events: {};
+    };
+    'IlluminanceMeasurement': {
+        features: {};
+        attributes: {
+            lightSensorType: MatterEnum | null;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            minMeasuredValue: number | null;
+            tolerance: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'JointFabricAdministrator': {
+        features: {};
+        attributes: {
+            administratorFabricIndex: FabricIndex | null;
+        };
+        commands: {
+            addICAC: {
+                icacValue: Bytes;
+            };
+            announceJointFabricAdministrator: {
+                endpointId: EndpointNumber;
+            };
+            iCACCSRRequest: undefined;
+            openJointCommissioningWindow: {
+                commissioningTimeout: number;
+                pakePasscodeVerifier: Bytes;
+                discriminator: number;
+                iterations: number;
+                salt: Bytes;
+            };
+            transferAnchorComplete: undefined;
+            transferAnchorRequest: undefined;
+        };
+        events: {};
+    };
+    'JointFabricDatastore': {
+        features: {};
+        attributes: {
+            adminList: MatterStruct[];
+            anchorNodeId: NodeId;
+            anchorRootCa: Bytes;
+            anchorVendorId: VendorId;
+            endpointBindingList: MatterStruct[];
+            endpointGroupIdList: MatterStruct[];
+            friendlyName: string;
+            groupKeySetList: MatterStruct[];
+            groupList: MatterStruct[];
+            nodeAclList: MatterStruct[];
+            nodeEndpointList: MatterStruct[];
+            nodeKeySetList: MatterStruct[];
+            nodeList: MatterStruct[];
+            status: MatterStruct;
+        };
+        commands: {
+            addACLToNode: {
+                nodeId: NodeId;
+                aclEntry: MatterStruct;
+            };
+            addAdmin: {
+                nodeId: NodeId;
+                friendlyName: string;
+                vendorId: VendorId;
+                icac: Bytes;
+            };
+            addBindingToEndpointForNode: {
+                nodeId: NodeId;
+                endpointId: EndpointNumber;
+                binding: MatterStruct;
+            };
+            addGroup: {
+                groupId: GroupId;
+                friendlyName: string;
+                groupKeySetId: number | null;
+                groupCat: number | null;
+                groupCatVersion: number | null;
+                groupPermission: MatterEnum;
+            };
+            addGroupIDToEndpointForNode: {
+                nodeId: NodeId;
+                endpointId: EndpointNumber;
+                groupId: GroupId;
+            };
+            addKeySet: {
+                groupKeySet: MatterStruct;
+            };
+            addPendingNode: {
+                nodeId: NodeId;
+                friendlyName: string;
+            };
+            refreshNode: {
+                nodeId: NodeId;
+            };
+            removeACLFromNode: {
+                listId: number;
+                nodeId: NodeId;
+            };
+            removeAdmin: {
+                nodeId: NodeId;
+            };
+            removeBindingFromEndpointForNode: {
+                listId: number;
+                endpointId: EndpointNumber;
+                nodeId: NodeId;
+            };
+            removeGroup: {
+                groupId: GroupId;
+            };
+            removeGroupIDFromEndpointForNode: {
+                nodeId: NodeId;
+                endpointId: EndpointNumber;
+                groupId: GroupId;
+            };
+            removeKeySet: {
+                groupKeySetId: number;
+            };
+            removeNode: {
+                nodeId: NodeId;
+            };
+            updateAdmin: {
+                nodeId: NodeId | null;
+                friendlyName: string | null;
+                icac: Bytes | null;
+            };
+            updateEndpointForNode: {
+                endpointId: EndpointNumber;
+                nodeId: NodeId;
+                friendlyName: string;
+            };
+            updateGroup: {
+                groupId: GroupId;
+                friendlyName: string | null;
+                groupKeySetId: number | null;
+                groupCat: number | null;
+                groupCatVersion: number | null;
+                groupPermission: MatterEnum | null;
+            };
+            updateKeySet: {
+                groupKeySet: MatterStruct;
+            };
+            updateNode: {
+                nodeId: NodeId;
+                friendlyName: string;
+            };
+        };
+        events: {};
+    };
+    'KeypadInput': {
+        features: {
+            LK: 'LocationKeys';
+            NV: 'NavigationKeyCodes';
+            NK: 'NumberKeys';
+        };
+        attributes: {};
+        commands: {
+            sendKey: {
+                keyCode: MatterEnum;
+            };
+        };
+        events: {};
+    };
+    'LabelCluster': {
+        features: {};
+        attributes: {
+            labelList: LabelStruct[];
+        };
+        commands: {};
+        events: {};
+    };
+    'LaundryDryerControls': {
+        features: {};
+        attributes: {
+            selectedDrynessLevel: MatterEnum | null;
+            supportedDrynessLevels: MatterEnum[];
+        };
+        commands: {};
+        events: {};
+    };
+    'LaundryWasherControls': {
+        features: {
+            RINSE: 'Rinse';
+            SPIN: 'Spin';
+        };
+        attributes: {
+            numberOfRinses: MatterEnum;
+            spinSpeedCurrent: number | null;
+            spinSpeeds: string[];
+            supportedRinses: MatterEnum[];
+        };
+        commands: {};
+        events: {};
+    };
+    'LaundryWasherMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'LevelControl': {
+        features: {
+            FQ: 'Frequency';
+            LT: 'Lighting';
+            OO: 'OnOff';
+        };
+        attributes: {
+            currentFrequency: number;
+            currentLevel: number | null;
+            defaultMoveRate: number | null;
+            maxFrequency: number;
+            maxLevel: number;
+            minFrequency: number;
+            minLevel: number;
+            offTransitionTime: number | null;
+            onLevel: number | null;
+            onOffTransitionTime: number;
+            onTransitionTime: number | null;
+            options: MatterBitmap;
+            remainingTime: number;
+            startUpCurrentLevel: number | null;
+        };
+        commands: {
+            move: {
+                moveMode: MatterEnum;
+                rate: number | null;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToClosestFrequency: {
+                frequency: number;
+            };
+            moveToLevel: {
+                level: number;
+                transitionTime: number | null;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            moveToLevelWithOnOff: undefined;
+            moveWithOnOff: undefined;
+            step: {
+                stepMode: MatterEnum;
+                stepSize: number;
+                transitionTime: number | null;
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stepWithOnOff: undefined;
+            stop: {
+                optionsMask: MatterBitmap;
+                optionsOverride: MatterBitmap;
+            };
+            stopWithOnOff: undefined;
+        };
+        events: {};
+    };
+    'LocalizationConfiguration': {
+        features: {};
+        attributes: {
+            activeLocale: string;
+            supportedLocales: string[];
+        };
+        commands: {};
+        events: {};
+    };
+    'LowPower': {
+        features: {};
+        attributes: {};
+        commands: {
+            sleep: undefined;
+        };
+        events: {};
+    };
+    'MediaInput': {
+        features: {
+            NU: 'NameUpdates';
+        };
+        attributes: {
+            currentInput: number;
+            inputList: MatterStruct[];
+        };
+        commands: {
+            hideInputStatus: undefined;
+            renameInput: {
+                index: number;
+                name: string;
+            };
+            selectInput: {
+                index: number;
+            };
+            showInputStatus: undefined;
+        };
+        events: {};
+    };
+    'MediaPlayback': {
+        features: {
+            AS: 'AdvancedSeek';
+            AA: 'AudioAdvance';
+            AT: 'AudioTracks';
+            TT: 'TextTracks';
+            VS: 'VariableSpeed';
+        };
+        attributes: {
+            activeAudioTrack: MatterStruct | null;
+            activeTextTrack: MatterStruct | null;
+            availableAudioTracks: MatterStruct[] | null;
+            availableTextTracks: MatterStruct[] | null;
+            currentState: MatterEnum;
+            duration: Int64 | null;
+            playbackSpeed: number;
+            sampledPosition: MatterStruct | null;
+            seekRangeEnd: Int64 | null;
+            seekRangeStart: Int64 | null;
+            startTime: EpochUs | null;
+        };
+        commands: {
+            activateAudioTrack: {
+                trackId: string;
+                audioOutputIndex: number | null;
+            };
+            activateTextTrack: {
+                trackId: string;
+            };
+            deactivateTextTrack: undefined;
+            fastForward: {
+                audioAdvanceUnmuted: boolean;
+            };
+            next: undefined;
+            pause: undefined;
+            play: undefined;
+            previous: undefined;
+            rewind: {
+                audioAdvanceUnmuted: boolean;
+            };
+            seek: {
+                position: Int64;
+            };
+            skipBackward: {
+                deltaPositionMilliseconds: Int64;
+            };
+            skipForward: {
+                deltaPositionMilliseconds: Int64;
+            };
+            startOver: undefined;
+            stop: undefined;
+        };
+        events: {
+            stateChanged: {
+                currentState: MatterEnum;
+                startTime: EpochUs;
+                duration: Int64;
+                sampledPosition: MatterStruct;
+                playbackSpeed: number;
+                seekRangeEnd: Int64;
+                seekRangeStart: Int64;
+                data: Bytes;
+                audioAdvanceUnmuted: boolean;
+            };
+        };
+    };
+    'Messages': {
+        features: {
+            RPLY: 'ConfirmationReply';
+            RESP: 'ConfirmationResponse';
+            PROT: 'ProtectedMessages';
+            CONF: 'ReceivedConfirmation';
+        };
+        attributes: {
+            activeMessageIDs: Bytes[];
+            messages: MatterStruct[];
+        };
+        commands: {
+            cancelMessagesRequest: {
+                messageIDs: Bytes[];
+            };
+            presentMessagesRequest: {
+                messageId: Bytes;
+                priority: MatterEnum;
+                messageControl: MatterBitmap;
+                startTime: EpochS | null;
+                duration: Int64 | null;
+                messageText: string;
+                responses: MatterStruct[];
+            };
+        };
+        events: {
+            messageQueued: {
+                messageId: Bytes;
+            };
+            messagePresented: {
+                messageId: Bytes;
+            };
+            messageComplete: {
+                messageId: Bytes;
+                responseId: number | null;
+                reply: string | null;
+                futureMessagesPreference: MatterEnum | null;
+            };
+        };
+    };
+    'MeterIdentification': {
+        features: {
+            PWRTHLD: 'PowerThreshold';
+        };
+        attributes: {
+            meterSerialNumber: string | null;
+            meterType: MatterEnum | null;
+            pointOfDelivery: string | null;
+            powerThreshold: MatterStruct | null;
+            protocolVersion: string | null;
+        };
+        commands: {};
+        events: {};
+    };
+    'MicrowaveOvenControl': {
+        features: {
+            PWRNUM: 'PowerAsNumber';
+            WATTS: 'PowerInWatts';
+            PWRLMTS: 'PowerNumberLimits';
+        };
+        attributes: {
+            cookTime: ElapsedS;
+            maxCookTime: ElapsedS;
+            maxPower: number;
+            minPower: number;
+            powerSetting: number;
+            powerStep: number;
+            selectedWattIndex: number;
+            supportedWatts: number[];
+            wattRating: number;
+        };
+        commands: {
+            addMoreTime: {
+                timeToAdd: ElapsedS;
+            };
+            setCookingParameters: {
+                cookMode: number;
+                cookTime: ElapsedS;
+                powerSetting: number;
+                wattSettingIndex: number;
+                startAfterSetting: boolean;
+            };
+        };
+        events: {};
+    };
+    'MicrowaveOvenMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'ModeBaseCluster': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'ModeSelect': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            description: string;
+            onMode: ModeId | null;
+            standardNamespace: MatterEnum | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'NetworkCommissioning': {
+        features: {
+            ET: 'EthernetNetworkInterface';
+            TH: 'ThreadNetworkInterface';
+            WI: 'WiFiNetworkInterface';
+        };
+        attributes: {
+            connectMaxTimeSeconds: number;
+            interfaceEnabled: boolean;
+            lastConnectErrorValue: number | null;
+            lastNetworkId: Bytes | null;
+            lastNetworkingStatus: MatterEnum | null;
+            maxNetworks: number;
+            networks: MatterStruct[];
+            scanMaxTimeSeconds: number;
+            supportedThreadFeatures: MatterBitmap;
+            supportedWiFiBands: MatterEnum[];
+            threadVersion: number;
+        };
+        commands: {
+            addOrUpdateThreadNetwork: {
+                operationalDataset: Bytes;
+                breadcrumb: Int64;
+            };
+            addOrUpdateWiFiNetwork: {
+                ssid: Bytes;
+                credentials: Bytes;
+                breadcrumb: Int64;
+            };
+            connectNetwork: {
+                networkId: Bytes;
+                breadcrumb: Int64;
+            };
+            removeNetwork: {
+                networkId: Bytes;
+                breadcrumb: Int64;
+            };
+            reorderNetwork: {
+                networkId: Bytes;
+                networkIndex: number;
+                breadcrumb: Int64;
+            };
+            scanNetworks: {
+                ssid: Bytes | null;
+                breadcrumb: Int64;
+            };
+        };
+        events: {};
+    };
+    'NitrogenDioxideConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'OccupancySensing': {
+        features: {
+            AIR: 'ActiveInfrared';
+            OTHER: 'Other';
+            PIR: 'PassiveInfrared';
+            PHY: 'PhysicalContact';
+            RAD: 'Radar';
+            RFS: 'RFSensing';
+            US: 'Ultrasonic';
+            VIS: 'Vision';
+        };
+        attributes: {
+            holdTime: number;
+            holdTimeLimits: MatterStruct;
+            occupancy: MatterBitmap;
+            occupancySensorType: MatterEnum;
+            occupancySensorTypeBitmap: MatterBitmap;
+            physicalContactOccupiedToUnoccupiedDelay: number;
+            physicalContactUnoccupiedToOccupiedDelay: number;
+            physicalContactUnoccupiedToOccupiedThreshold: number;
+            pirOccupiedToUnoccupiedDelay: number;
+            pirUnoccupiedToOccupiedDelay: number;
+            pirUnoccupiedToOccupiedThreshold: number;
+            ultrasonicOccupiedToUnoccupiedDelay: number;
+            ultrasonicUnoccupiedToOccupiedDelay: number;
+            ultrasonicUnoccupiedToOccupiedThreshold: number;
+        };
+        commands: {};
+        events: {
+            occupancyChanged: {
+                occupancy: MatterBitmap;
+            };
+        };
+    };
+    'OnOff': {
+        features: {
+            DF: 'DeadFrontBehavior';
+            LT: 'Lighting';
+            OFFONLY: 'OffOnly';
+        };
+        attributes: {
+            globalSceneControl: boolean;
+            offWaitTime: number;
+            onOff: boolean;
+            onTime: number;
+            startUpOnOff: MatterEnum | null;
+        };
+        commands: {
+            off: undefined;
+            offWithEffect: {
+                effectIdentifier: MatterEnum;
+                effectVariant: MatterEnum;
+            };
+            on: undefined;
+            onWithRecallGlobalScene: undefined;
+            onWithTimedOff: {
+                onOffControl: MatterBitmap;
+                onTime: number;
+                offWaitTime: number;
+            };
+            toggle: undefined;
+        };
+        events: {};
+    };
+    'OperationalCredentials': {
+        features: {};
+        attributes: {
+            commissionedFabrics: number;
+            currentFabricIndex: number;
+            fabrics: MatterStruct[];
+            noCs: MatterStruct[];
+            supportedFabrics: number;
+            trustedRootCertificates: Bytes[];
+        };
+        commands: {
+            addNOC: {
+                nocValue: Bytes;
+                icacValue: Bytes;
+                ipkValue: Bytes;
+                caseAdminSubject: SubjectId;
+                adminVendorId: VendorId;
+            };
+            addTrustedRootCertificate: {
+                rootCaCertificate: Bytes;
+            };
+            attestationRequest: {
+                attestationNonce: Bytes;
+            };
+            certificateChainRequest: {
+                certificateType: MatterEnum;
+            };
+            cSRRequest: {
+                csrNonce: Bytes;
+                isForUpdateNoc: boolean;
+            };
+            removeFabric: {
+                fabricIndex: FabricIndex;
+            };
+            setVIDVerificationStatement: {
+                vendorId: VendorId;
+                vidVerificationStatement: Bytes;
+                vvsc: Bytes;
+            };
+            signVIDVerificationRequest: {
+                fabricIndex: FabricIndex;
+                clientChallenge: Bytes;
+            };
+            updateFabricLabel: {
+                label: string;
+            };
+            updateNOC: {
+                nocValue: Bytes;
+                icacValue: Bytes;
+            };
+        };
+        events: {};
+    };
+    'OperationalState': {
+        features: {};
+        attributes: {
+            countdownTime: ElapsedS | null;
+            currentPhase: number | null;
+            operationalError: MatterStruct;
+            operationalState: MatterEnum;
+            operationalStateList: MatterStruct[];
+            phaseList: string[] | null;
+        };
+        commands: {
+            pause: undefined;
+            resume: undefined;
+            start: undefined;
+            stop: undefined;
+        };
+        events: {
+            operationalError: {
+                errorState: MatterStruct;
+            };
+            operationCompletion: {
+                completionErrorCode: MatterEnum;
+                totalOperationalTime: ElapsedS | null;
+                pausedTime: ElapsedS | null;
+            };
+        };
+    };
+    'OTASoftwareUpdateProvider': {
+        features: {};
+        attributes: {};
+        commands: {
+            applyUpdateRequest: {
+                updateToken: Bytes;
+                newVersion: number;
+            };
+            notifyUpdateApplied: {
+                updateToken: Bytes;
+                softwareVersion: number;
+            };
+            queryImage: {
+                vendorId: VendorId;
+                productId: number;
+                softwareVersion: number;
+                protocolsSupported: MatterEnum[];
+                hardwareVersion: number;
+                location: string;
+                requestorCanConsent: boolean;
+                metadataForProvider: Bytes;
+            };
+        };
+        events: {};
+    };
+    'OTASoftwareUpdateRequestor': {
+        features: {};
+        attributes: {
+            defaultOtaProviders: MatterStruct[];
+            updatePossible: boolean;
+            updateState: MatterEnum;
+            updateStateProgress: number | null;
+        };
+        commands: {
+            announceOTAProvider: {
+                providerNodeId: NodeId;
+                vendorId: VendorId;
+                announcementReason: MatterEnum;
+                metadataForNode: Bytes;
+                endpoint: EndpointNumber;
+            };
+        };
+        events: {
+            stateTransition: {
+                previousState: MatterEnum;
+                newState: MatterEnum;
+                reason: MatterEnum;
+                targetSoftwareVersion: number | null;
+            };
+            versionApplied: {
+                softwareVersion: number;
+                productId: number;
+            };
+            downloadError: {
+                softwareVersion: number;
+                bytesDownloaded: Int64;
+                progressPercent: number | null;
+                platformCode: Int64 | null;
+            };
+        };
+    };
+    'OvenCavityOperationalState': {
+        features: {};
+        attributes: {
+            countdownTime: ElapsedS | null;
+            currentPhase: number | null;
+            operationalError: MatterStruct;
+            operationalState: MatterEnum;
+            operationalStateList: MatterStruct[];
+            phaseList: string[] | null;
+        };
+        commands: {
+            pause: undefined;
+            resume: undefined;
+            start: undefined;
+            stop: undefined;
+        };
+        events: {
+            operationalError: {
+                errorState: MatterStruct;
+            };
+            operationCompletion: {
+                completionErrorCode: MatterEnum;
+                totalOperationalTime: ElapsedS | null;
+                pausedTime: ElapsedS | null;
+            };
+        };
+    };
+    'OvenMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'OzoneConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'PM10ConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'PM1ConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'PM2.5ConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'PowerSource': {
+        features: {
+            BAT: 'Battery';
+            RECHG: 'Rechargeable';
+            REPLC: 'Replaceable';
+            WIRED: 'Wired';
+        };
+        attributes: {
+            activeBatChargeFaults: MatterEnum[];
+            activeBatFaults: MatterEnum[];
+            activeWiredFaults: MatterEnum[];
+            batAnsiDesignation: string;
+            batApprovedChemistry: MatterEnum;
+            batCapacity: number;
+            batChargeLevel: MatterEnum;
+            batChargeState: MatterEnum;
+            batChargingCurrent: number | null;
+            batCommonDesignation: MatterEnum;
+            batFunctionalWhileCharging: boolean;
+            batIecDesignation: string;
+            batPercentRemaining: number | null;
+            batPresent: boolean;
+            batQuantity: number;
+            batReplaceability: MatterEnum;
+            batReplacementDescription: string;
+            batReplacementNeeded: boolean;
+            batTimeRemaining: number | null;
+            batTimeToFullCharge: number | null;
+            batVoltage: number | null;
+            description: string;
+            endpointList: EndpointNumber[];
+            order: number;
+            status: MatterEnum;
+            wiredAssessedCurrent: number | null;
+            wiredAssessedInputFrequency: number | null;
+            wiredAssessedInputVoltage: number | null;
+            wiredCurrentType: MatterEnum;
+            wiredMaximumCurrent: number;
+            wiredNominalVoltage: number;
+            wiredPresent: boolean;
+        };
+        commands: {};
+        events: {
+            wiredFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+            batFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+            batChargeFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+        };
+    };
+    'PowerSourceConfiguration': {
+        features: {};
+        attributes: {
+            sources: EndpointNumber[];
+        };
+        commands: {};
+        events: {};
+    };
+    'PowerTopology': {
+        features: {
+            DYPF: 'DynamicPowerFlow';
+            NODE: 'NodeTopology';
+            SET: 'SetTopology';
+            TREE: 'TreeTopology';
+        };
+        attributes: {
+            activeEndpoints: EndpointNumber[];
+            availableEndpoints: EndpointNumber[];
+        };
+        commands: {};
+        events: {};
+    };
+    'PressureMeasurement': {
+        features: {
+            EXT: 'Extended';
+        };
+        attributes: {
+            maxMeasuredValue: number | null;
+            maxScaledValue: number | null;
+            measuredValue: number | null;
+            minMeasuredValue: number | null;
+            minScaledValue: number | null;
+            scale: number;
+            scaledTolerance: number;
+            scaledValue: number | null;
+            tolerance: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'PumpConfigurationandControl': {
+        features: {
+            AUTO: 'Automatic';
+            PRSCOMP: 'CompensatedPressure';
+            FLW: 'ConstantFlow';
+            PRSCONST: 'ConstantPressure';
+            SPD: 'ConstantSpeed';
+            TEMP: 'ConstantTemperature';
+            LOCAL: 'LocalOperation';
+        };
+        attributes: {
+            alarmMask: MatterBitmap;
+            capacity: number | null;
+            controlMode: MatterEnum;
+            effectiveControlMode: MatterEnum;
+            effectiveOperationMode: MatterEnum;
+            lifetimeEnergyConsumed: number | null;
+            lifetimeRunningHours: number | null;
+            maxCompPressure: number | null;
+            maxConstFlow: number | null;
+            maxConstPressure: number | null;
+            maxConstSpeed: number | null;
+            maxConstTemp: number | null;
+            maxFlow: number | null;
+            maxPressure: number | null;
+            maxSpeed: number | null;
+            minCompPressure: number | null;
+            minConstFlow: number | null;
+            minConstPressure: number | null;
+            minConstSpeed: number | null;
+            minConstTemp: number | null;
+            operationMode: MatterEnum;
+            power: number | null;
+            pumpStatus: MatterBitmap;
+            speed: number | null;
+        };
+        commands: {};
+        events: {
+            supplyVoltageLow: undefined;
+            supplyVoltageHigh: undefined;
+            powerMissingPhase: undefined;
+            systemPressureLow: undefined;
+            systemPressureHigh: undefined;
+            dryRunning: undefined;
+            motorTemperatureHigh: undefined;
+            pumpMotorFatalFailure: undefined;
+            electronicTemperatureHigh: undefined;
+            pumpBlocked: undefined;
+            sensorFailure: undefined;
+            electronicNonFatalFailure: undefined;
+            electronicFatalFailure: undefined;
+            generalFault: undefined;
+            leakage: undefined;
+            airDetection: undefined;
+            turbineOperation: undefined;
+        };
+    };
+    'PushAVStreamTransport': {
+        features: {
+            METADATA: 'Metadata';
+            PERZONESENS: 'PerZoneSensitivity';
+        };
+        attributes: {
+            currentConnections: MatterStruct[];
+            supportedFormats: MatterStruct[];
+        };
+        commands: {
+            allocatePushTransport: {
+                transportOptions: MatterStruct;
+            };
+            deallocatePushTransport: {
+                connectionId: PushTransportConnectionId;
+            };
+            findTransport: {
+                connectionId: PushTransportConnectionId | null;
+            };
+            manuallyTriggerTransport: {
+                connectionId: PushTransportConnectionId;
+                activationReason: MatterEnum;
+                timeControl: MatterStruct;
+                userDefined: Bytes;
+            };
+            modifyPushTransport: {
+                connectionId: PushTransportConnectionId;
+                transportOptions: MatterStruct;
+            };
+            setTransportStatus: {
+                connectionId: PushTransportConnectionId | null;
+                transportStatus: MatterEnum;
+            };
+        };
+        events: {
+            pushTransportBegin: {
+                connectionId: PushTransportConnectionId;
+                triggerType: MatterEnum;
+                activationReason: MatterEnum;
+                containerType: MatterEnum;
+                cmafSessionNumber: Int64;
+            };
+            pushTransportEnd: {
+                connectionId: PushTransportConnectionId;
+                containerType: MatterEnum;
+                cmafSessionNumber: Int64;
+            };
+        };
+    };
+    'RadonConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'RefrigeratorAlarm': {
+        features: {
+            RESET: 'Reset';
+        };
+        attributes: {
+            latch: MatterBitmap;
+            mask: MatterBitmap;
+            state: MatterBitmap;
+            supported: MatterBitmap;
+        };
+        commands: {
+            modifyEnabledAlarms: {
+                mask: MatterBitmap;
+            };
+            reset: {
+                alarms: MatterBitmap;
+            };
+        };
+        events: {
+            notify: {
+                active: MatterBitmap;
+                inactive: MatterBitmap;
+                state: MatterBitmap;
+                mask: MatterBitmap;
+            };
+        };
+    };
+    'RefrigeratorAndTemperatureControlledCabinetMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'RelativeHumidityMeasurement': {
+        features: {};
+        attributes: {
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            minMeasuredValue: number | null;
+            tolerance: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'ResourceMonitoringClusters': {
+        features: {
+            CON: 'Condition';
+            REP: 'ReplacementProductList';
+            WRN: 'Warning';
+        };
+        attributes: {
+            changeIndication: MatterEnum;
+            condition: Percent;
+            degradationDirection: MatterEnum;
+            inPlaceIndicator: boolean;
+            lastChangedTime: EpochS | null;
+            replacementProductList: MatterStruct[];
+        };
+        commands: {
+            resetCondition: undefined;
+        };
+        events: {};
+    };
+    'RVCCleanMode': {
+        features: {
+            DIRECTMODECH: 'DirectModeChange';
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'RVCOperationalState': {
+        features: {};
+        attributes: {
+            countdownTime: ElapsedS | null;
+            currentPhase: number | null;
+            operationalError: MatterStruct;
+            operationalState: MatterEnum;
+            operationalStateList: MatterStruct[];
+            phaseList: string[] | null;
+        };
+        commands: {
+            goHome: undefined;
+            pause: undefined;
+            resume: undefined;
+            start: undefined;
+            stop: undefined;
+        };
+        events: {
+            operationalError: {
+                errorState: MatterStruct;
+            };
+            operationCompletion: {
+                completionErrorCode: MatterEnum;
+                totalOperationalTime: ElapsedS | null;
+                pausedTime: ElapsedS | null;
+            };
+        };
+    };
+    'RVCRunMode': {
+        features: {
+            DIRECTMODECH: 'DirectModeChange';
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'ScenesManagement': {
+        features: {
+            SN: 'SceneNames';
+        };
+        attributes: {
+            doNotUse: never;
+            fabricSceneInfo: MatterStruct[];
+            sceneTableSize: number;
+        };
+        commands: {
+            addScene: {
+                groupId: GroupId;
+                sceneId: number;
+                transitionTime: number;
+                sceneName: string;
+                extensionFieldSetStructs: MatterStruct[];
+            };
+            copyScene: {
+                mode: MatterBitmap;
+                groupIdentifierFrom: GroupId;
+                sceneIdentifierFrom: number;
+                groupIdentifierTo: GroupId;
+                sceneIdentifierTo: number;
+            };
+            getSceneMembership: {
+                groupId: GroupId;
+            };
+            recallScene: {
+                groupId: GroupId;
+                sceneId: number;
+                transitionTime: number | null;
+            };
+            removeAllScenes: {
+                groupId: GroupId;
+            };
+            removeScene: {
+                groupId: GroupId;
+                sceneId: number;
+            };
+            storeScene: {
+                groupId: GroupId;
+                sceneId: number;
+            };
+            viewScene: {
+                groupId: GroupId;
+                sceneId: number;
+            };
+        };
+        events: {};
+    };
+    'ServiceArea': {
+        features: {
+            MAPS: 'Maps';
+            PROG: 'ProgressReporting';
+            SELRUN: 'SelectWhileRunning';
+        };
+        attributes: {
+            currentArea: number | null;
+            estimatedEndTime: EpochS | null;
+            progress: MatterStruct[];
+            selectedAreas: number[];
+            supportedAreas: MatterStruct[];
+            supportedMaps: MatterStruct[];
+        };
+        commands: {
+            selectAreas: {
+                newAreas: number[];
+            };
+            skipArea: {
+                skippedArea: number;
+            };
+        };
+        events: {};
+    };
+    'SmokeCOAlarm': {
+        features: {
+            CO: 'COAlarm';
+            SMOKE: 'SmokeAlarm';
+        };
+        attributes: {
+            batteryAlert: MatterEnum;
+            contaminationState: MatterEnum;
+            coState: MatterEnum;
+            deviceMuted: MatterEnum;
+            endOfServiceAlert: MatterEnum;
+            expiryDate: EpochS;
+            expressedState: MatterEnum;
+            hardwareFaultAlert: boolean;
+            interconnectCoAlarm: MatterEnum;
+            interconnectSmokeAlarm: MatterEnum;
+            smokeSensitivityLevel: MatterEnum;
+            smokeState: MatterEnum;
+            testInProgress: boolean;
+        };
+        commands: {
+            selfTestRequest: undefined;
+        };
+        events: {
+            smokeAlarm: {
+                alarmSeverityLevel: MatterEnum;
+            };
+            coAlarm: {
+                alarmSeverityLevel: MatterEnum;
+            };
+            lowBattery: {
+                alarmSeverityLevel: MatterEnum;
+            };
+            hardwareFault: undefined;
+            endOfService: undefined;
+            selfTestComplete: undefined;
+            alarmMuted: undefined;
+            muteEnded: undefined;
+            interconnectSmokeAlarm: {
+                alarmSeverityLevel: MatterEnum;
+            };
+            interconnectCoAlarm: {
+                alarmSeverityLevel: MatterEnum;
+            };
+            allClear: undefined;
+        };
+    };
+    'SoftwareDiagnostics': {
+        features: {
+            WTRMRK: 'Watermarks';
+        };
+        attributes: {
+            currentHeapFree: Int64;
+            currentHeapHighWatermark: Int64;
+            currentHeapUsed: Int64;
+            threadMetrics: MatterStruct[];
+        };
+        commands: {
+            resetWatermarks: undefined;
+        };
+        events: {
+            softwareFault: {
+                id: Int64;
+                name: string;
+                faultRecording: Bytes;
+            };
+        };
+    };
+    'SoilMeasurement': {
+        features: {};
+        attributes: {
+            soilMoistureMeasuredValue: Percent | null;
+            soilMoistureMeasurementLimits: MatterStruct;
+        };
+        commands: {};
+        events: {};
+    };
+    'Switch': {
+        features: {
+            AS: 'ActionSwitch';
+            LS: 'LatchingSwitch';
+            MS: 'MomentarySwitch';
+            MSL: 'MomentarySwitchLongPress';
+            MSM: 'MomentarySwitchMultiPress';
+            MSR: 'MomentarySwitchRelease';
+        };
+        attributes: {
+            currentPosition: number;
+            multiPressMax: number;
+            numberOfPositions: number;
+        };
+        commands: {};
+        events: {
+            switchLatched: {
+                newPosition: number;
+            };
+            initialPress: {
+                newPosition: number;
+            };
+            longPress: {
+                newPosition: number;
+            };
+            shortRelease: {
+                previousPosition: number;
+            };
+            longRelease: {
+                previousPosition: number;
+            };
+            multiPressOngoing: {
+                newPosition: number;
+                currentNumberOfPressesCounted: number;
+            };
+            multiPressComplete: {
+                previousPosition: number;
+                totalNumberOfPressesCounted: number;
+            };
+        };
+    };
+    'TargetNavigator': {
+        features: {};
+        attributes: {
+            currentTarget: number;
+            targetList: MatterStruct[];
+        };
+        commands: {
+            navigateTarget: {
+                target: number;
+                data: string;
+            };
+        };
+        events: {
+            targetUpdated: {
+                targetList: MatterStruct[];
+                currentTarget: number;
+                data: Bytes;
+            };
+        };
+    };
+    'TemperatureControl': {
+        features: {
+            TL: 'TemperatureLevel';
+            TN: 'TemperatureNumber';
+            STEP: 'TemperatureStep';
+        };
+        attributes: {
+            maxTemperature: Temperature100Ths;
+            minTemperature: Temperature100Ths;
+            selectedTemperatureLevel: number;
+            step: Temperature100Ths;
+            supportedTemperatureLevels: string[];
+            temperatureSetpoint: Temperature100Ths;
+        };
+        commands: {
+            setTemperature: {
+                targetTemperature: Temperature100Ths;
+                targetTemperatureLevel: number;
+            };
+        };
+        events: {};
+    };
+    'TemperatureMeasurement': {
+        features: {};
+        attributes: {
+            maxMeasuredValue: Temperature100Ths | null;
+            measuredValue: Temperature100Ths | null;
+            minMeasuredValue: Temperature100Ths | null;
+            tolerance: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'Thermostat': {
+        features: {
+            AUTO: 'AutoMode';
+            COOL: 'Cooling';
+            HEAT: 'Heating';
+            LTNE: 'LocalTemperatureNotExposed';
+            MSCH: 'MatterScheduleConfiguration';
+            OCC: 'Occupancy';
+            PRES: 'Presets';
+            SB: 'Setback';
+        };
+        attributes: {
+            absMaxCoolSetpointLimit: Temperature100Ths;
+            absMaxHeatSetpointLimit: Temperature100Ths;
+            absMinCoolSetpointLimit: Temperature100Ths;
+            absMinHeatSetpointLimit: Temperature100Ths;
+            acCapacity: number;
+            acCapacityFormat: MatterEnum;
+            acCoilTemperature: Temperature100Ths | null;
+            acCompressorType: MatterEnum;
+            acErrorCode: MatterBitmap;
+            acLouverPosition: MatterEnum;
+            acRefrigerantType: MatterEnum;
+            activePresetHandle: Bytes | null;
+            activeScheduleHandle: Bytes | null;
+            acType: MatterEnum;
+            controlSequenceOfOperation: MatterEnum;
+            emergencyHeatDelta: UnsignedTemperature10Ths;
+            hvacSystemTypeConfiguration: never;
+            localTemperature: Temperature100Ths | null;
+            localTemperatureCalibration: SignedTemperature10Ths;
+            maxCoolSetpointLimit: Temperature100Ths;
+            maxHeatSetpointLimit: Temperature100Ths;
+            minCoolSetpointLimit: Temperature100Ths;
+            minHeatSetpointLimit: Temperature100Ths;
+            minSetpointDeadBand: SignedTemperature10Ths;
+            numberOfPresets: number;
+            numberOfSchedules: number;
+            numberOfScheduleTransitionPerDay: number | null;
+            numberOfScheduleTransitions: number;
+            occupancy: MatterBitmap;
+            occupiedCoolingSetpoint: Temperature100Ths;
+            occupiedHeatingSetpoint: Temperature100Ths;
+            occupiedSetback: never;
+            occupiedSetbackMax: never;
+            occupiedSetbackMin: never;
+            outdoorTemperature: Temperature100Ths | null;
+            piCoolingDemand: never;
+            piHeatingDemand: never;
+            presets: MatterStruct[];
+            presetTypes: MatterStruct[];
+            remoteSensing: MatterBitmap;
+            schedules: MatterStruct[];
+            scheduleTypes: MatterStruct[];
+            setpointChangeAmount: number | null;
+            setpointChangeSource: MatterEnum;
+            setpointChangeSourceTimestamp: EpochS;
+            setpointHoldExpiryTimestamp: EpochS | null;
+            systemMode: MatterEnum;
+            temperatureSetpointHold: MatterEnum;
+            temperatureSetpointHoldDuration: number | null;
+            thermostatProgrammingOperationMode: never;
+            thermostatRunningMode: MatterEnum;
+            thermostatRunningState: MatterBitmap;
+            unoccupiedCoolingSetpoint: Temperature100Ths;
+            unoccupiedHeatingSetpoint: Temperature100Ths;
+            unoccupiedSetback: never;
+            unoccupiedSetbackMax: never;
+            unoccupiedSetbackMin: never;
+        };
+        commands: {
+            setActivePresetRequest: {
+                presetHandle: Bytes | null;
+            };
+            setActiveScheduleRequest: {
+                scheduleHandle: Bytes;
+            };
+            setpointRaiseLower: {
+                mode: MatterEnum;
+                amount: number;
+            };
+        };
+        events: {};
+    };
+    'ThermostatUserInterfaceConfiguration': {
+        features: {};
+        attributes: {
+            keypadLockout: MatterEnum;
+            scheduleProgrammingVisibility: MatterEnum;
+            temperatureDisplayMode: MatterEnum;
+        };
+        commands: {};
+        events: {};
+    };
+    'ThreadBorderRouterManagement': {
+        features: {
+            PC: 'PANChange';
+        };
+        attributes: {
+            activeDatasetTimestamp: Int64 | null;
+            borderAgentId: Bytes;
+            borderRouterName: string;
+            interfaceEnabled: boolean;
+            pendingDatasetTimestamp: Int64 | null;
+            threadVersion: number;
+        };
+        commands: {
+            getActiveDatasetRequest: undefined;
+            getPendingDatasetRequest: undefined;
+            setActiveDatasetRequest: {
+                activeDataset: Bytes;
+                breadcrumb: Int64;
+            };
+            setPendingDatasetRequest: {
+                pendingDataset: Bytes;
+            };
+        };
+        events: {};
+    };
+    'ThreadNetworkDiagnostics': {
+        features: {
+            ERRCNT: 'ErrorCounts';
+            MACCNT: 'MACCounts';
+            MLECNT: 'MLECounts';
+            PKTCNT: 'PacketCounts';
+        };
+        attributes: {
+            activeNetworkFaultsList: MatterEnum[];
+            activeTimestamp: Int64 | null;
+            attachAttemptCount: number;
+            betterPartitionAttachAttemptCount: number;
+            channel: number | null;
+            channelPage0Mask: Bytes | null;
+            childRoleCount: number;
+            dataVersion: number | null;
+            delay: number | null;
+            detachedRoleCount: number;
+            extAddress: Int64 | null;
+            extendedPanId: Int64 | null;
+            leaderRoleCount: number;
+            leaderRouterId: number | null;
+            meshLocalPrefix: Bytes | null;
+            neighborTable: MatterStruct[];
+            networkName: string | null;
+            operationalDatasetComponents: MatterStruct | null;
+            overrunCount: Int64;
+            panId: number | null;
+            parentChangeCount: number;
+            partitionId: number | null;
+            partitionIdChangeCount: number;
+            pendingTimestamp: Int64 | null;
+            rloc16: number | null;
+            routerRoleCount: number;
+            routeTable: MatterStruct[];
+            routingRole: MatterEnum | null;
+            rxAddressFilteredCount: number;
+            rxBeaconCount: number;
+            rxBeaconRequestCount: number;
+            rxBroadcastCount: number;
+            rxDataCount: number;
+            rxDataPollCount: number;
+            rxDestAddrFilteredCount: number;
+            rxDuplicatedCount: number;
+            rxErrFcsCount: number;
+            rxErrInvalidSrcAddrCount: number;
+            rxErrNoFrameCount: number;
+            rxErrOtherCount: number;
+            rxErrSecCount: number;
+            rxErrUnknownNeighborCount: number;
+            rxOtherCount: number;
+            rxTotalCount: number;
+            rxUnicastCount: number;
+            securityPolicy: MatterStruct | null;
+            stableDataVersion: number | null;
+            txAckedCount: number;
+            txAckRequestedCount: number;
+            txBeaconCount: number;
+            txBeaconRequestCount: number;
+            txBroadcastCount: number;
+            txDataCount: number;
+            txDataPollCount: number;
+            txDirectMaxRetryExpiryCount: number;
+            txErrAbortCount: number;
+            txErrBusyChannelCount: number;
+            txErrCcaCount: number;
+            txIndirectMaxRetryExpiryCount: number;
+            txNoAckRequestedCount: number;
+            txOtherCount: number;
+            txRetryCount: number;
+            txTotalCount: number;
+            txUnicastCount: number;
+            weighting: number | null;
+        };
+        commands: {
+            resetCounts: undefined;
+        };
+        events: {
+            connectionStatus: {
+                connectionStatus: MatterEnum;
+            };
+            networkFaultChange: {
+                current: MatterEnum[];
+                previous: MatterEnum[];
+            };
+        };
+    };
+    'ThreadNetworkDirectory': {
+        features: {};
+        attributes: {
+            preferredExtendedPanId: Bytes | null;
+            threadNetworks: MatterStruct[];
+            threadNetworkTableSize: number;
+        };
+        commands: {
+            addNetwork: {
+                operationalDataset: Bytes;
+            };
+            getOperationalDataset: {
+                extendedPanId: Bytes;
+            };
+            removeNetwork: {
+                extendedPanId: Bytes;
+            };
+        };
+        events: {};
+    };
+    'TimeFormatLocalization': {
+        features: {
+            CALFMT: 'CalendarFormat';
+        };
+        attributes: {
+            activeCalendarType: MatterEnum;
+            hourFormat: MatterEnum;
+            supportedCalendarTypes: MatterEnum[];
+        };
+        commands: {};
+        events: {};
+    };
+    'TimeSynchronization': {
+        features: {
+            NTPC: 'NTPClient';
+            NTPS: 'NTPServer';
+            TSC: 'TimeSyncClient';
+            TZ: 'TimeZone';
+        };
+        attributes: {
+            defaultNtp: string | null;
+            dstOffset: MatterStruct[];
+            dstOffsetListMaxSize: number;
+            granularity: MatterEnum;
+            localTime: EpochUs | null;
+            ntpServerAvailable: boolean;
+            supportsDnsResolve: boolean;
+            timeSource: MatterEnum;
+            timeZone: MatterStruct[];
+            timeZoneDatabase: MatterEnum;
+            timeZoneListMaxSize: number;
+            trustedTimeSource: MatterStruct | null;
+            utcTime: EpochUs | null;
+        };
+        commands: {
+            setDefaultNTP: {
+                defaultNtp: string | null;
+            };
+            setDSTOffset: {
+                dstOffset: MatterStruct[];
+            };
+            setTimeZone: {
+                timeZone: MatterStruct[];
+            };
+            setTrustedTimeSource: {
+                trustedTimeSource: MatterStruct | null;
+            };
+            setUTCTime: {
+                utcTime: EpochUs;
+                granularity: MatterEnum;
+                timeSource: MatterEnum;
+            };
+        };
+        events: {
+            dstTableEmpty: undefined;
+            dstStatus: {
+                dstOffsetActive: boolean;
+            };
+            timeZoneStatus: {
+                offset: number;
+                name: string;
+            };
+            timeFailure: undefined;
+            missingTrustedTimeSource: undefined;
+        };
+    };
+    'TLSCertificateManagement': {
+        features: {};
+        attributes: {
+            maxClientCertificates: number;
+            maxRootCertificates: number;
+            provisionedClientCertificates: MatterStruct[];
+            provisionedRootCertificates: MatterStruct[];
+        };
+        commands: {
+            clientCSR: {
+                nonce: Bytes;
+                ccdid: TLSCCDId | null;
+            };
+            findClientCertificate: {
+                ccdid: TLSCCDId | null;
+            };
+            findRootCertificate: {
+                caid: TLSCAId | null;
+            };
+            lookupClientCertificate: {
+                fingerprint: Bytes;
+            };
+            lookupRootCertificate: {
+                fingerprint: Bytes;
+            };
+            provisionClientCertificate: {
+                ccdid: TLSCCDId;
+                clientCertificate: Bytes;
+                intermediateCertificates: Bytes[];
+            };
+            provisionRootCertificate: {
+                certificate: Bytes;
+                caid: TLSCAId | null;
+            };
+            removeClientCertificate: {
+                ccdid: TLSCCDId;
+            };
+            removeRootCertificate: {
+                caid: TLSCAId;
+            };
+        };
+        events: {};
+    };
+    'TLSClientManagement': {
+        features: {};
+        attributes: {
+            maxProvisioned: number;
+            provisionedEndpoints: MatterStruct[];
+        };
+        commands: {
+            findEndpoint: {
+                endpointId: TLSEndpointId;
+            };
+            provisionEndpoint: {
+                hostname: Bytes;
+                port: number;
+                caid: TLSCAId;
+                ccdid: TLSCCDId | null;
+                endpointId: TLSEndpointId | null;
+            };
+            removeEndpoint: {
+                endpointId: TLSEndpointId;
+            };
+        };
+        events: {};
+    };
+    'TotalVolatileOrganicCompoundsConcentrationMeasurement': {
+        features: {
+            AVG: 'AverageMeasurement';
+            CRI: 'CriticalLevel';
+            LEV: 'LevelIndication';
+            MED: 'MediumLevel';
+            MEA: 'NumericMeasurement';
+            PEA: 'PeakMeasurement';
+        };
+        attributes: {
+            averageMeasuredValue: number | null;
+            averageMeasuredValueWindow: ElapsedS;
+            levelValue: MatterEnum;
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            measurementMedium: MatterEnum;
+            measurementUnit: MatterEnum;
+            minMeasuredValue: number | null;
+            peakMeasuredValue: number | null;
+            peakMeasuredValueWindow: ElapsedS;
+            uncertainty: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'UnitLocalization': {
+        features: {
+            TEMP: 'TemperatureUnit';
+        };
+        attributes: {
+            supportedTemperatureUnits: MatterEnum[];
+            temperatureUnit: MatterEnum;
+        };
+        commands: {};
+        events: {};
+    };
+    'UserLabel': {
+        features: {};
+        attributes: {
+            labelList: LabelStruct[];
+        };
+        commands: {};
+        events: {};
+    };
+    'ValveConfigurationandControl': {
+        features: {
+            LVL: 'Level';
+            TS: 'TimeSync';
+        };
+        attributes: {
+            autoCloseTime: EpochUs | null;
+            currentLevel: Percent | null;
+            currentState: MatterEnum | null;
+            defaultOpenDuration: ElapsedS | null;
+            defaultOpenLevel: Percent;
+            levelStep: number;
+            openDuration: ElapsedS | null;
+            remainingDuration: ElapsedS | null;
+            targetLevel: Percent | null;
+            targetState: MatterEnum | null;
+            valveFault: MatterBitmap;
+        };
+        commands: {
+            close: undefined;
+            open: {
+                openDuration: ElapsedS | null;
+                targetLevel: Percent;
+            };
+        };
+        events: {
+            valveStateChanged: {
+                valveState: MatterEnum;
+                valveLevel: Percent;
+            };
+            valveFault: {
+                valveFault: MatterBitmap;
+            };
+        };
+    };
+    'WakeOnLAN': {
+        features: {};
+        attributes: {
+            linkLocalAddress: Bytes;
+            macAddress: string;
+        };
+        commands: {};
+        events: {};
+    };
+    'WaterContentMeasurementClusters': {
+        features: {};
+        attributes: {
+            maxMeasuredValue: number | null;
+            measuredValue: number | null;
+            minMeasuredValue: number | null;
+            tolerance: number;
+        };
+        commands: {};
+        events: {};
+    };
+    'WaterHeaterManagement': {
+        features: {
+            EM: 'EnergyManagement';
+            TP: 'TankPercent';
+        };
+        attributes: {
+            boostState: MatterEnum;
+            estimatedHeatRequired: Int64;
+            heatDemand: MatterBitmap;
+            heaterTypes: MatterBitmap;
+            tankPercentage: Percent;
+            tankVolume: number;
+        };
+        commands: {
+            boost: {
+                boostInfo: MatterStruct;
+            };
+            cancelBoost: undefined;
+        };
+        events: {
+            boostStarted: {
+                boostInfo: MatterStruct;
+            };
+            boostEnded: undefined;
+        };
+    };
+    'WaterHeaterMode': {
+        features: {
+            DEPONOFF: 'OnOff';
+        };
+        attributes: {
+            currentMode: ModeId;
+            onMode: ModeId | null;
+            startUpMode: ModeId | null;
+            supportedModes: SupportedModes[];
+        };
+        commands: {
+            changeToMode: {
+                newMode: number;
+            };
+        };
+        events: {};
+    };
+    'WaterTankLevelMonitoring': {
+        features: {
+            CON: 'Condition';
+            REP: 'ReplacementProductList';
+            WRN: 'Warning';
+        };
+        attributes: {
+            changeIndication: MatterEnum;
+            condition: Percent;
+            degradationDirection: MatterEnum;
+            inPlaceIndicator: boolean;
+            lastChangedTime: EpochS | null;
+            replacementProductList: MatterStruct[];
+        };
+        commands: {
+            resetCondition: undefined;
+        };
+        events: {};
+    };
+    'WebRTCTransportProvider': {
+        features: {
+            METADATA: 'Metadata';
+        };
+        attributes: {
+            currentSessions: MatterStruct[];
+        };
+        commands: {
+            endSession: {
+                webRtcSessionId: WebRTCSessionId;
+                reason: MatterEnum;
+            };
+            provideAnswer: {
+                webRtcSessionId: WebRTCSessionId;
+                sdp: string;
+            };
+            provideICECandidates: {
+                webRtcSessionId: WebRTCSessionId;
+                iceCandidates: MatterStruct[];
+            };
+        };
+        events: {};
+    };
+    'WebRTCTransportRequestor': {
+        features: {};
+        attributes: {
+            currentSessions: MatterStruct[];
+        };
+        commands: {
+            answer: {
+                webRtcSessionId: WebRTCSessionId;
+                sdp: string;
+            };
+            end: {
+                webRtcSessionId: WebRTCSessionId;
+                reason: MatterEnum;
+            };
+            iCECandidates: {
+                webRtcSessionId: WebRTCSessionId;
+                iceCandidates: MatterStruct[];
+            };
+            offer: {
+                webRtcSessionId: WebRTCSessionId;
+                sdp: string;
+                iceServers: MatterStruct[];
+                iceTransportPolicy: string;
+            };
+        };
+        events: {};
+    };
+    'WiFiNetworkDiagnostics': {
+        features: {
+            ERRCNT: 'ErrorCounts';
+            PKTCNT: 'PacketCounts';
+        };
+        attributes: {
+            beaconLostCount: number | null;
+            beaconRxCount: number | null;
+            bssid: Bytes | null;
+            channelNumber: number | null;
+            currentMaxRate: Int64 | null;
+            overrunCount: Int64 | null;
+            packetMulticastRxCount: number | null;
+            packetMulticastTxCount: number | null;
+            packetUnicastRxCount: number | null;
+            packetUnicastTxCount: number | null;
+            rssi: number | null;
+            securityType: MatterEnum | null;
+            wiFiVersion: MatterEnum | null;
+        };
+        commands: {
+            resetCounts: undefined;
+        };
+        events: {
+            disconnection: {
+                reasonCode: number;
+            };
+            associationFailure: {
+                associationFailureCause: MatterEnum;
+                status: number;
+            };
+            connectionStatus: {
+                connectionStatus: MatterEnum;
+            };
+        };
+    };
+    'WiFiNetworkManagement': {
+        features: {};
+        attributes: {
+            passphraseSurrogate: Int64 | null;
+            ssid: Bytes | null;
+        };
+        commands: {
+            networkPassphraseRequest: undefined;
+        };
+        events: {};
+    };
+    'WindowCovering': {
+        features: {
+            LF: 'Lift';
+            PA_LF: 'PositionAwareLift';
+            PA_TL: 'PositionAwareTilt';
+            TL: 'Tilt';
+        };
+        attributes: {
+            configStatus: MatterBitmap;
+            currentPositionLiftPercent100Ths: Percent100Ths | null;
+            currentPositionLiftPercentage: Percent | null;
+            currentPositionTiltPercent100Ths: Percent100Ths | null;
+            currentPositionTiltPercentage: Percent | null;
+            endProductType: MatterEnum;
+            mode: MatterBitmap;
+            numberOfActuationsLift: number;
+            numberOfActuationsTilt: number;
+            operationalStatus: MatterBitmap;
+            safetyStatus: MatterBitmap;
+            targetPositionLiftPercent100Ths: Percent100Ths | null;
+            targetPositionTiltPercent100Ths: Percent100Ths | null;
+            type: MatterEnum;
+        };
+        commands: {
+            downOrClose: undefined;
+            goToLiftPercentage: {
+                liftPercent100ThsValue: Percent100Ths;
+            };
+            goToTiltPercentage: {
+                tiltPercent100ThsValue: Percent100Ths;
+            };
+            stopMotion: undefined;
+            upOrOpen: undefined;
+        };
+        events: {};
+    };
+    'ZoneManagement': {
+        features: {
+            FOCUSZONES: 'FocusZones';
+            PERZONESENS: 'PerZoneSensitivity';
+            TWODCART: 'TwoDimensionalCartesianZone';
+            USERDEFINED: 'UserDefined';
+        };
+        attributes: {
+            maxUserDefinedZones: number;
+            maxZones: number;
+            sensitivity: number;
+            sensitivityMax: number;
+            triggers: MatterStruct[];
+            twoDCartesianMax: MatterStruct;
+            zones: MatterStruct[];
+        };
+        commands: {
+            createOrUpdateTrigger: {
+                trigger: MatterStruct;
+            };
+            createTwoDCartesianZone: {
+                zone: MatterStruct;
+            };
+            removeTrigger: {
+                zoneId: ZoneId;
+            };
+            removeZone: {
+                zoneId: ZoneId;
+            };
+            updateTwoDCartesianZone: {
+                zoneId: ZoneId;
+                zone: MatterStruct;
+            };
+        };
+        events: {
+            zoneTriggered: {
+                zone: ZoneId;
+                reason: MatterEnum;
+            };
+            zoneStopped: {
+                zone: ZoneId;
+                reason: MatterEnum;
+            };
+        };
+    };
+};